A guide to Refactoring mock clones in cloudstack

@Test

public void testCreateSuccess() {

    AccountService accountService = Mockito.mock(AccountService.class);

    Account account = Mockito.mock(Account.class);

    Mockito.when(accountService.getAccount(nullable(Long.class))).thenReturn(account);

    addVpnUserCmd._accountService = accountService;

    RemoteAccessVpnService ravService = Mockito.mock(RemoteAccessVpnService.class);

    VpnUser vpnUser = Mockito.mock(VpnUser.class);

    Mockito.when(ravService.addVpnUser(anyLong(), isNull(), isNull())).thenReturn(vpnUser);

    addVpnUserCmd._ravService = ravService;

    addVpnUserCmd.create();

}

private static AccountService createMockAccountService(Account account) {
    AccountService accountService = Mockito.mock(AccountService.class);
    Mockito.when(accountService.getAccount(Mockito.<Long>nullable(Long.class))).thenReturn(account);
    return accountService;
}

@Test

public void testCreateFailure() {

    AccountService accountService = Mockito.mock(AccountService.class);

    Account account = Mockito.mock(Account.class);

    Mockito.when(accountService.getAccount(nullable(Long.class))).thenReturn(account);

    addVpnUserCmd._accountService = accountService;

    RemoteAccessVpnService ravService = Mockito.mock(RemoteAccessVpnService.class);

    Mockito.when(ravService.addVpnUser(anyLong(), isNull(), isNull())).thenReturn(null);

    addVpnUserCmd._ravService = ravService;

    try {

        addVpnUserCmd.create();

    } catch (ServerApiException exception) {

        Assert.assertEquals("Failed to add vpn user", exception.getDescription());

    }

}

private static AccountService createMockAccountService(Account account) {
    AccountService accountService = Mockito.mock(AccountService.class);
    Mockito.when(accountService.getAccount(Mockito.<Long>nullable(Long.class))).thenReturn(account);
    return accountService;
}

@Test

public void testCreateSuccess() {

    AccountService accountService = Mockito.mock(AccountService.class);

    Account account = Mockito.mock(Account.class);

    Mockito.when(accountService.getAccount(anyLong())).thenReturn(account);

    VolumeApiService volumeApiService = Mockito.mock(VolumeApiService.class);

    Snapshot snapshot = Mockito.mock(Snapshot.class);

    try {

        Mockito.when(volumeApiService.takeSnapshot(nullable(Long.class), nullable(Long.class), isNull(), nullable(Account.class), nullable(Boolean.class), nullable(Snapshot.LocationType.class), nullable(Boolean.class), nullable(Map.class))).thenReturn(snapshot);

    } catch (Exception e) {

        Assert.fail("Received exception when success expected " + e.getMessage());

    }

    responseGenerator = Mockito.mock(ResponseGenerator.class);

    SnapshotResponse snapshotResponse = Mockito.mock(SnapshotResponse.class);

    Mockito.when(responseGenerator.createSnapshotResponse(snapshot)).thenReturn(snapshotResponse);

    Mockito.doNothing().when(snapshotResponse).setAccountName(anyString());

    createSnapshotCmd._accountService = accountService;

    createSnapshotCmd._responseGenerator = responseGenerator;

    createSnapshotCmd._volumeService = volumeApiService;

    try {

        createSnapshotCmd.execute();

    } catch (Exception e) {

        Assert.fail("Received exception when success expected " + e.getMessage());

    }

}

private static AccountService createMockAccountService(Account account) {
    AccountService accountService = Mockito.mock(AccountService.class);
    Mockito.when(accountService.getAccount(Mockito.anyLong())).thenReturn(account);
    return accountService;
}

@Test

public void testCreateFailure() {

    AccountService accountService = Mockito.mock(AccountService.class);

    Account account = Mockito.mock(Account.class);

    Mockito.when(accountService.getAccount(anyLong())).thenReturn(account);

    VolumeApiService volumeApiService = Mockito.mock(VolumeApiService.class);

    try {

        Mockito.when(volumeApiService.takeSnapshot(nullable(Long.class), nullable(Long.class), nullable(Long.class), nullable(Account.class), nullable(Boolean.class), nullable(Snapshot.LocationType.class), nullable(Boolean.class), anyObject())).thenReturn(null);

    } catch (Exception e) {

        Assert.fail("Received exception when success expected " + e.getMessage());

    }

    createSnapshotCmd._accountService = accountService;

    createSnapshotCmd._volumeService = volumeApiService;

    try {

        createSnapshotCmd.execute();

    } catch (ServerApiException exception) {

        Assert.assertEquals("Failed to create snapshot due to an internal error creating snapshot for volume 123", exception.getDescription());

    }

}

private static AccountService createMockAccountService(Account account) {
    AccountService accountService = Mockito.mock(AccountService.class);
    Mockito.when(accountService.getAccount(Mockito.anyLong())).thenReturn(account);
    return accountService;
}

@Test

public void execute() throws Exception {

    //      test with valid params and with admin who doesn't exist in cloudstack

    long domainId = 1;

    String type = "GROUP";

    String ldapDomain = "CN=test,DC=ccp,DC=Citrix,DC=com";

    Account.Type accountType = Account.Type.DOMAIN_ADMIN;

    String username = "admin";

    long accountId = 24;

    String accountName = "test";

    setHiddenField(linkAccountToLdapCmd, "ldapDomain", ldapDomain);

    setHiddenField(linkAccountToLdapCmd, "admin", username);

    setHiddenField(linkAccountToLdapCmd, "type", type);

    setHiddenField(linkAccountToLdapCmd, "domainId", domainId);

    setHiddenField(linkAccountToLdapCmd, "accountType", accountType.ordinal());

    setHiddenField(linkAccountToLdapCmd, "accountName", accountName);

    LinkAccountToLdapResponse response = new LinkAccountToLdapResponse(String.valueOf(domainId), type, ldapDomain, accountType.ordinal(), username, accountName);

    when(ldapManager.linkAccountToLdap(linkAccountToLdapCmd)).thenReturn(response);

    when(ldapManager.getUser(username, type, ldapDomain, 1L)).thenReturn(new LdapUser(username, "admin@ccp.citrix.com", "Admin", "Admin", ldapDomain, "ccp", false, null));

    when(accountService.getActiveAccountByName(username, domainId)).thenReturn(null);

    UserAccountVO userAccount = new UserAccountVO();

    userAccount.setAccountId(24);

    when(accountService.createUserAccount(eq(username), eq(""), eq("Admin"), eq("Admin"), eq("admin@ccp.citrix.com"), isNull(String.class), eq(username), eq(Account.Type.DOMAIN_ADMIN), eq(RoleType.DomainAdmin.getId()), eq(domainId), isNull(String.class), (java.util.Map<String, String>) isNull(), anyString(), anyString(), eq(User.Source.LDAP))).thenReturn(userAccount);

    linkAccountToLdapCmd.execute();

    LinkAccountToLdapResponse result = (LinkAccountToLdapResponse) linkAccountToLdapCmd.getResponseObject();

    assertEquals("objectName", BaseCmd.getCommandNameByClass(LinkAccountToLdapCmd.class), result.getObjectName());

    assertEquals("commandName", linkAccountToLdapCmd.getCommandName(), result.getResponseName());

    assertEquals("domainId", String.valueOf(domainId), result.getDomainId());

    assertEquals("type", type, result.getType());

    assertEquals("name", ldapDomain, result.getLdapDomain());

    assertEquals("accountId", String.valueOf(accountId), result.getAdminId());

}
@Before

public void setUp() throws NoSuchFieldException, IllegalAccessException {

    linkAccountToLdapCmd = new LinkAccountToLdapCmd();

    setHiddenField(linkAccountToLdapCmd, "_ldapManager", ldapManager);

    setHiddenField(linkAccountToLdapCmd, "_accountService", accountService);

}

public class MockAccountService {
    public static AccountService createMockAccountService(String username, long domainId, UserAccountVO userAccount) {
        AccountService accountService = Mockito.mock(AccountService.class);
        Mockito.when(accountService.createUserAccount(
                Mockito.eq(username),
                Mockito.eq(""),
                Mockito.eq("Admin"),
                Mockito.eq("Admin"),
                Mockito.eq("admin@ccp.citrix.com"),
                Mockito.isNull(String.class),
                Mockito.eq(username),
                Mockito.eq(Account.Type.DOMAIN_ADMIN),
                Mockito.eq(RoleType.DomainAdmin.getId()),
                Mockito.eq(domainId),
                Mockito.isNull(String.class),
                (java.util.Map<String, String>) Mockito.isNull(),
                Mockito.anyString(),
                Mockito.anyString(),
                Mockito.eq(User.Source.LDAP)
        )).thenReturn(userAccount);
        return accountService;
    }
}

@Before

public void setUp() throws NoSuchFieldException, IllegalAccessException {

    linkDomainToLdapCmd = new LinkDomainToLdapCmd();

    setHiddenField(linkDomainToLdapCmd, "_ldapManager", ldapManager);

    setHiddenField(linkDomainToLdapCmd, "_accountService", accountService);

}
@Test

public void execute() throws Exception {

    //      test with valid params and with admin who doesn't exist in cloudstack

    Long domainId = 1L;

    String type = "GROUP";

    String ldapDomain = "CN=test,DC=ccp,DC=Citrix,DC=com";

    Account.Type accountType = Account.Type.DOMAIN_ADMIN;

    String username = "admin";

    long accountId = 24;

    setHiddenField(linkDomainToLdapCmd, "ldapDomain", ldapDomain);

    setHiddenField(linkDomainToLdapCmd, "admin", username);

    setHiddenField(linkDomainToLdapCmd, "type", type);

    setHiddenField(linkDomainToLdapCmd, "domainId", domainId);

    setHiddenField(linkDomainToLdapCmd, "accountType", accountType.ordinal());

    LinkDomainToLdapResponse response = new LinkDomainToLdapResponse(domainId.toString(), type, ldapDomain, accountType.ordinal());

    when(ldapManager.linkDomainToLdap(linkDomainToLdapCmd)).thenReturn(response);

    when(ldapManager.getUser(username, type, ldapDomain, 1L)).thenReturn(new LdapUser(username, "admin@ccp.citrix.com", "Admin", "Admin", ldapDomain, "ccp", false, null));

    when(accountService.getActiveAccountByName(username, domainId)).thenReturn(null);

    UserAccountVO userAccount = new UserAccountVO();

    userAccount.setAccountId(24);

    when(accountService.createUserAccount(eq(username), eq(""), eq("Admin"), eq("Admin"), eq("admin@ccp.citrix.com"), isNull(String.class), eq(username), eq(Account.Type.DOMAIN_ADMIN), eq(RoleType.DomainAdmin.getId()), eq(domainId), isNull(String.class), (java.util.Map<String, String>) isNull(), anyString(), anyString(), eq(User.Source.LDAP))).thenReturn(userAccount);

    linkDomainToLdapCmd.execute();

    LinkDomainToLdapResponse result = (LinkDomainToLdapResponse) linkDomainToLdapCmd.getResponseObject();

    assertEquals("objectName", "LinkDomainToLdap", result.getObjectName());

    assertEquals("commandName", linkDomainToLdapCmd.getCommandName(), result.getResponseName());

    assertEquals("domainId", domainId.toString(), result.getDomainId());

    assertEquals("type", type, result.getType());

    assertEquals("name", ldapDomain, result.getLdapDomain());

    assertEquals("accountId", String.valueOf(accountId), result.getAdminId());

}

public class MockAccountService {
    public static AccountService createMockAccountService(String username, long domainId, UserAccountVO userAccount) {
        AccountService accountService = Mockito.mock(AccountService.class);
        Mockito.when(accountService.createUserAccount(
                Mockito.eq(username),
                Mockito.eq(""),
                Mockito.eq("Admin"),
                Mockito.eq("Admin"),
                Mockito.eq("admin@ccp.citrix.com"),
                Mockito.isNull(String.class),
                Mockito.eq(username),
                Mockito.eq(Account.Type.DOMAIN_ADMIN),
                Mockito.eq(RoleType.DomainAdmin.getId()),
                Mockito.eq(domainId),
                Mockito.isNull(String.class),
                (java.util.Map<String, String>) Mockito.isNull(),
                Mockito.anyString(),
                Mockito.anyString(),
                Mockito.eq(User.Source.LDAP)
        )).thenReturn(userAccount);
        return accountService;
    }
}

@Before

public void setUp() throws ConfigurationException {

    _element._resourceMgr = mock(ResourceManager.class);

    _element._agentMgr = _agentMgr;

    _element._networkMgr = _networkMgr;

    _element._networkModel = _networkModel;

    _element._hostDao = _hostDao;

    _element._configMgr = _configMgr;

    _element._ciscoVnmcDao = _ciscoVnmcDao;

    _element._ciscoAsa1000vDao = _ciscoAsa1000vDao;

    _element._networkAsa1000vMapDao = _networkAsa1000vMapDao;

    _element._clusterVsmMapDao = _clusterVsmMapDao;

    _element._vsmDeviceDao = _vsmDeviceDao;

    _element._vlanDao = _vlanDao;

    _element._entityMgr = _entityMgr;

    // Standard responses

    when(_networkModel.isProviderForNetwork(Provider.CiscoVnmc, 1L)).thenReturn(true);

    _element.configure("CiscoVnmcTestElement", Collections.<String, Object>emptyMap());

}
@Test

public void implementTest() throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException {

    URI uri = URI.create("vlan://123");

    Network network = mock(Network.class);

    when(network.getId()).thenReturn(1L);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Vlan);

    when(network.getDataCenterId()).thenReturn(1L);

    when(network.getGateway()).thenReturn("1.1.1.1");

    when(network.getBroadcastUri()).thenReturn(uri);

    when(network.getCidr()).thenReturn("1.1.1.0/24");

    NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(1L);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    DeployDestination dest = mock(DeployDestination.class);

    Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("d1");

    Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("a1");

    ReservationContext context = mock(ReservationContext.class);

    when(context.getDomain()).thenReturn(dom);

    when(context.getAccount()).thenReturn(acc);

    DataCenter dc = mock(DataCenter.class);

    when(dc.getNetworkType()).thenReturn(NetworkType.Advanced);

    when(_entityMgr.findById(DataCenter.class, network.getDataCenterId())).thenReturn(dc);

    List<CiscoVnmcControllerVO> devices = new ArrayList<CiscoVnmcControllerVO>();

    devices.add(mock(CiscoVnmcControllerVO.class));

    when(_ciscoVnmcDao.listByPhysicalNetwork(network.getPhysicalNetworkId())).thenReturn(devices);

    CiscoAsa1000vDeviceVO asaVO = mock(CiscoAsa1000vDeviceVO.class);

    when(asaVO.getInPortProfile()).thenReturn("foo");

    when(asaVO.getManagementIp()).thenReturn("1.2.3.4");

    List<CiscoAsa1000vDeviceVO> asaList = new ArrayList<CiscoAsa1000vDeviceVO>();

    asaList.add(asaVO);

    when(_ciscoAsa1000vDao.listByPhysicalNetwork(network.getPhysicalNetworkId())).thenReturn(asaList);

    when(_networkAsa1000vMapDao.findByNetworkId(network.getId())).thenReturn(mock(NetworkAsa1000vMapVO.class));

    when(_networkAsa1000vMapDao.findByAsa1000vId(anyLong())).thenReturn(null);

    when(_networkAsa1000vMapDao.persist(any(NetworkAsa1000vMapVO.class))).thenReturn(mock(NetworkAsa1000vMapVO.class));

    when(_networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.SourceNat, Provider.CiscoVnmc)).thenReturn(true);

    ClusterVSMMapVO clusterVsmMap = mock(ClusterVSMMapVO.class);

    when(_clusterVsmMapDao.findByClusterId(anyLong())).thenReturn(clusterVsmMap);

    CiscoNexusVSMDeviceVO vsmDevice = mock(CiscoNexusVSMDeviceVO.class);

    when(vsmDevice.getUserName()).thenReturn("foo");

    when(vsmDevice.getPassword()).thenReturn("bar");

    when(vsmDevice.getipaddr()).thenReturn("1.2.3.4");

    when(_vsmDeviceDao.findById(anyLong())).thenReturn(vsmDevice);

    HostVO hostVO = mock(HostVO.class);

    when(hostVO.getId()).thenReturn(1L);

    when(_hostDao.findById(anyLong())).thenReturn(hostVO);

    Ip ip = mock(Ip.class);

    when(ip.addr()).thenReturn("1.2.3.4");

    PublicIp publicIp = mock(PublicIp.class);

    when(publicIp.getAddress()).thenReturn(ip);

    when(publicIp.getState()).thenReturn(IpAddress.State.Releasing);

    when(publicIp.getAccountId()).thenReturn(1L);

    when(publicIp.isSourceNat()).thenReturn(true);

    when(publicIp.getVlanTag()).thenReturn("123");

    when(publicIp.getGateway()).thenReturn("1.1.1.1");

    when(publicIp.getNetmask()).thenReturn("1.1.1.1");

    when(publicIp.getMacAddress()).thenReturn(null);

    when(publicIp.isOneToOneNat()).thenReturn(true);

    when(_ipAddrMgr.assignSourceNatIpAddressToGuestNetwork(acc, network)).thenReturn(publicIp);

    VlanVO vlanVO = mock(VlanVO.class);

    when(vlanVO.getVlanGateway()).thenReturn("1.1.1.1");

    List<VlanVO> vlanVOList = new ArrayList<VlanVO>();

    when(_vlanDao.listVlansByPhysicalNetworkId(network.getPhysicalNetworkId())).thenReturn(vlanVOList);

    Answer answer = mock(Answer.class);

    when(answer.getResult()).thenReturn(true);

    when(_agentMgr.easySend(anyLong(), any(CreateLogicalEdgeFirewallCommand.class))).thenReturn(answer);

    when(_agentMgr.easySend(anyLong(), any(ConfigureNexusVsmForAsaCommand.class))).thenReturn(answer);

    when(_agentMgr.easySend(anyLong(), any(SetSourceNatCommand.class))).thenReturn(answer);

    when(_agentMgr.easySend(anyLong(), any(AssociateAsaWithLogicalEdgeFirewallCommand.class))).thenReturn(answer);

    assertTrue(_element.implement(network, offering, dest, context));

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

@Test

public void applyFWRulesTest() throws ResourceUnavailableException {

    URI uri = URI.create("vlan://123");

    Network network = mock(Network.class);

    when(network.getId()).thenReturn(1L);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Vlan);

    when(network.getDataCenterId()).thenReturn(1L);

    when(network.getBroadcastUri()).thenReturn(uri);

    when(network.getCidr()).thenReturn("1.1.1.0/24");

    when(network.getState()).thenReturn(Network.State.Implemented);

    Ip ip = mock(Ip.class);

    when(ip.addr()).thenReturn("1.2.3.4");

    IpAddress ipAddress = mock(IpAddress.class);

    when(ipAddress.getAddress()).thenReturn(ip);

    when(_networkModel.getIp(anyLong())).thenReturn(ipAddress);

    when(_networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.Firewall, Provider.CiscoVnmc)).thenReturn(true);

    List<CiscoVnmcControllerVO> devices = new ArrayList<CiscoVnmcControllerVO>();

    devices.add(mock(CiscoVnmcControllerVO.class));

    when(_ciscoVnmcDao.listByPhysicalNetwork(network.getPhysicalNetworkId())).thenReturn(devices);

    when(_networkAsa1000vMapDao.findByNetworkId(network.getId())).thenReturn(mock(NetworkAsa1000vMapVO.class));

    HostVO hostVO = mock(HostVO.class);

    when(hostVO.getId()).thenReturn(1L);

    when(_hostDao.findById(anyLong())).thenReturn(hostVO);

    FirewallRule rule = mock(FirewallRule.class);

    when(rule.getSourceIpAddressId()).thenReturn(1L);

    List<FirewallRule> rules = new ArrayList<FirewallRule>();

    rules.add(rule);

    Answer answer = mock(Answer.class);

    when(answer.getResult()).thenReturn(true);

    when(_agentMgr.easySend(anyLong(), any(SetFirewallRulesCommand.class))).thenReturn(answer);

    assertTrue(_element.applyFWRules(network, rules));

}
@Before

public void setUp() throws ConfigurationException {

    _element._resourceMgr = mock(ResourceManager.class);

    _element._agentMgr = _agentMgr;

    _element._networkMgr = _networkMgr;

    _element._networkModel = _networkModel;

    _element._hostDao = _hostDao;

    _element._configMgr = _configMgr;

    _element._ciscoVnmcDao = _ciscoVnmcDao;

    _element._ciscoAsa1000vDao = _ciscoAsa1000vDao;

    _element._networkAsa1000vMapDao = _networkAsa1000vMapDao;

    _element._clusterVsmMapDao = _clusterVsmMapDao;

    _element._vsmDeviceDao = _vsmDeviceDao;

    _element._vlanDao = _vlanDao;

    _element._entityMgr = _entityMgr;

    // Standard responses

    when(_networkModel.isProviderForNetwork(Provider.CiscoVnmc, 1L)).thenReturn(true);

    _element.configure("CiscoVnmcTestElement", Collections.<String, Object>emptyMap());

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

@Before

public void setUp() throws ConfigurationException {

    _element._resourceMgr = mock(ResourceManager.class);

    _element._agentMgr = _agentMgr;

    _element._networkMgr = _networkMgr;

    _element._networkModel = _networkModel;

    _element._hostDao = _hostDao;

    _element._configMgr = _configMgr;

    _element._ciscoVnmcDao = _ciscoVnmcDao;

    _element._ciscoAsa1000vDao = _ciscoAsa1000vDao;

    _element._networkAsa1000vMapDao = _networkAsa1000vMapDao;

    _element._clusterVsmMapDao = _clusterVsmMapDao;

    _element._vsmDeviceDao = _vsmDeviceDao;

    _element._vlanDao = _vlanDao;

    _element._entityMgr = _entityMgr;

    // Standard responses

    when(_networkModel.isProviderForNetwork(Provider.CiscoVnmc, 1L)).thenReturn(true);

    _element.configure("CiscoVnmcTestElement", Collections.<String, Object>emptyMap());

}
@Test

public void applyPRulesTest() throws ResourceUnavailableException {

    URI uri = URI.create("vlan://123");

    Network network = mock(Network.class);

    when(network.getId()).thenReturn(1L);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Vlan);

    when(network.getDataCenterId()).thenReturn(1L);

    when(network.getBroadcastUri()).thenReturn(uri);

    when(network.getCidr()).thenReturn("1.1.1.0/24");

    when(network.getState()).thenReturn(Network.State.Implemented);

    Ip ip = mock(Ip.class);

    when(ip.addr()).thenReturn("1.2.3.4");

    IpAddress ipAddress = mock(IpAddress.class);

    when(ipAddress.getAddress()).thenReturn(ip);

    when(ipAddress.getVlanId()).thenReturn(1L);

    when(_networkModel.getIp(anyLong())).thenReturn(ipAddress);

    when(_networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.PortForwarding, Provider.CiscoVnmc)).thenReturn(true);

    List<CiscoVnmcControllerVO> devices = new ArrayList<CiscoVnmcControllerVO>();

    devices.add(mock(CiscoVnmcControllerVO.class));

    when(_ciscoVnmcDao.listByPhysicalNetwork(network.getPhysicalNetworkId())).thenReturn(devices);

    when(_networkAsa1000vMapDao.findByNetworkId(network.getId())).thenReturn(mock(NetworkAsa1000vMapVO.class));

    HostVO hostVO = mock(HostVO.class);

    when(hostVO.getId()).thenReturn(1L);

    when(_hostDao.findById(anyLong())).thenReturn(hostVO);

    VlanVO vlanVO = mock(VlanVO.class);

    when(vlanVO.getVlanTag()).thenReturn(null);

    when(_vlanDao.findById(anyLong())).thenReturn(vlanVO);

    PortForwardingRule rule = mock(PortForwardingRule.class);

    when(rule.getSourceIpAddressId()).thenReturn(1L);

    when(rule.getDestinationIpAddress()).thenReturn(ip);

    List<PortForwardingRule> rules = new ArrayList<PortForwardingRule>();

    rules.add(rule);

    Answer answer = mock(Answer.class);

    when(answer.getResult()).thenReturn(true);

    when(_agentMgr.easySend(anyLong(), any(SetPortForwardingRulesCommand.class))).thenReturn(answer);

    assertTrue(_element.applyPFRules(network, rules));

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

@Before

public void setUp() throws ConfigurationException {

    _element._resourceMgr = mock(ResourceManager.class);

    _element._agentMgr = _agentMgr;

    _element._networkMgr = _networkMgr;

    _element._networkModel = _networkModel;

    _element._hostDao = _hostDao;

    _element._configMgr = _configMgr;

    _element._ciscoVnmcDao = _ciscoVnmcDao;

    _element._ciscoAsa1000vDao = _ciscoAsa1000vDao;

    _element._networkAsa1000vMapDao = _networkAsa1000vMapDao;

    _element._clusterVsmMapDao = _clusterVsmMapDao;

    _element._vsmDeviceDao = _vsmDeviceDao;

    _element._vlanDao = _vlanDao;

    _element._entityMgr = _entityMgr;

    // Standard responses

    when(_networkModel.isProviderForNetwork(Provider.CiscoVnmc, 1L)).thenReturn(true);

    _element.configure("CiscoVnmcTestElement", Collections.<String, Object>emptyMap());

}
@Test

public void applyStaticNatsTest() throws ResourceUnavailableException {

    URI uri = URI.create("vlan://123");

    Network network = mock(Network.class);

    when(network.getId()).thenReturn(1L);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Vlan);

    when(network.getDataCenterId()).thenReturn(1L);

    when(network.getBroadcastUri()).thenReturn(uri);

    when(network.getCidr()).thenReturn("1.1.1.0/24");

    when(network.getState()).thenReturn(Network.State.Implemented);

    Ip ip = mock(Ip.class);

    when(ip.addr()).thenReturn("1.2.3.4");

    IpAddress ipAddress = mock(IpAddress.class);

    when(ipAddress.getAddress()).thenReturn(ip);

    when(ipAddress.getVlanId()).thenReturn(1L);

    when(_networkModel.getIp(anyLong())).thenReturn(ipAddress);

    when(_networkModel.isProviderSupportServiceInNetwork(network.getId(), Service.StaticNat, Provider.CiscoVnmc)).thenReturn(true);

    List<CiscoVnmcControllerVO> devices = new ArrayList<CiscoVnmcControllerVO>();

    devices.add(mock(CiscoVnmcControllerVO.class));

    when(_ciscoVnmcDao.listByPhysicalNetwork(network.getPhysicalNetworkId())).thenReturn(devices);

    when(_networkAsa1000vMapDao.findByNetworkId(network.getId())).thenReturn(mock(NetworkAsa1000vMapVO.class));

    HostVO hostVO = mock(HostVO.class);

    when(hostVO.getId()).thenReturn(1L);

    when(_hostDao.findById(anyLong())).thenReturn(hostVO);

    VlanVO vlanVO = mock(VlanVO.class);

    when(vlanVO.getVlanTag()).thenReturn(null);

    when(_vlanDao.findById(anyLong())).thenReturn(vlanVO);

    StaticNat rule = mock(StaticNat.class);

    when(rule.getSourceIpAddressId()).thenReturn(1L);

    when(rule.getDestIpAddress()).thenReturn("1.2.3.4");

    when(rule.isForRevoke()).thenReturn(false);

    List<StaticNat> rules = new ArrayList<StaticNat>();

    rules.add(rule);

    Answer answer = mock(Answer.class);

    when(answer.getResult()).thenReturn(true);

    when(_agentMgr.easySend(anyLong(), any(SetStaticNatRulesCommand.class))).thenReturn(answer);

    assertTrue(_element.applyStaticNats(network, rules));

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

@Before

public void setUp() throws ConfigurationException {

    element.resourceMgr = mock(ResourceManager.class);

    element.networkManager = networkManager;

    element.ntwkSrvcDao = ntwkSrvcDao;

    element.networkModel = networkModel;

    element.agentMgr = agentManager;

    element.hostDao = hostDao;

    element.niciraNvpDao = niciraNvpDao;

    element.niciraNvpRouterMappingDao = niciraNvpRouterMappingDao;

    element.vlanDao = vlanDao;

    element.ipAddrMgr = ipAddressManager;

    // Standard responses

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    element.configure("NiciraNvpTestElement", Collections.<String, Object>emptyMap());

}
@Test

public void canHandleTest() {

    final Network net = mock(Network.class);

    when(net.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Lswitch);

    when(net.getId()).thenReturn(NETWORK_ID);

    when(ntwkSrvcDao.canProviderSupportServiceInNetwork(NETWORK_ID, Service.Connectivity, Provider.NiciraNvp)).thenReturn(true);

    // Golden path

    assertTrue(element.canHandle(net, Service.Connectivity));

    when(net.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Vlan);

    // Only broadcastdomaintype lswitch is supported

    assertFalse(element.canHandle(net, Service.Connectivity));

    when(net.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Lswitch);

    when(ntwkSrvcDao.canProviderSupportServiceInNetwork(NETWORK_ID, Service.Connectivity, Provider.NiciraNvp)).thenReturn(false);

    // No nvp provider in the network

    assertFalse(element.canHandle(net, Service.Connectivity));

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(false);

    when(ntwkSrvcDao.canProviderSupportServiceInNetwork(NETWORK_ID, Service.Connectivity, Provider.NiciraNvp)).thenReturn(true);

    // NVP provider does not provide Connectivity for this network

    assertFalse(element.canHandle(net, Service.Connectivity));

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    // Only service Connectivity is supported

    assertFalse(element.canHandle(net, Service.Dhcp));

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

@Test

public void implementIsolatedNetworkTest() throws ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException, URISyntaxException {

    final Network network = mock(Network.class);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Lswitch);

    when(network.getBroadcastUri()).thenReturn(new URI("lswitch:aaaaa"));

    when(network.getId()).thenReturn(NETWORK_ID);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getGuestType()).thenReturn(GuestType.Isolated);

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    when(ntwkSrvcDao.canProviderSupportServiceInNetwork(NETWORK_ID, Service.Connectivity, Provider.NiciraNvp)).thenReturn(true);

    final NiciraNvpDeviceVO device = mock(NiciraNvpDeviceVO.class);

    when(niciraNvpDao.listByPhysicalNetwork(NETWORK_ID)).thenReturn(Arrays.asList(new NiciraNvpDeviceVO[] { device }));

    when(device.getId()).thenReturn(1L);

    when(device.getHostId()).thenReturn(NICIRA_NVP_HOST_ID);

    HostVO niciraNvpHost = mock(HostVO.class);

    when(niciraNvpHost.getId()).thenReturn(NICIRA_NVP_HOST_ID);

    when(hostDao.findById(NICIRA_NVP_HOST_ID)).thenReturn(niciraNvpHost);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    final DeployDestination dest = mock(DeployDestination.class);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext context = mock(ReservationContext.class);

    when(context.getDomain()).thenReturn(dom);

    when(context.getAccount()).thenReturn(acc);

    //ISOLATED NETWORK

    when(networkModel.isProviderSupportServiceInNetwork(NETWORK_ID, Service.SourceNat, Provider.NiciraNvp)).thenReturn(true);

    PublicIp sourceNatIp = mock(PublicIp.class);

    Ip ip = mock(Ip.class);

    when(ip.addr()).thenReturn("10.0.0.0");

    when(sourceNatIp.getAddress()).thenReturn(ip);

    when(sourceNatIp.getVlanNetmask()).thenReturn("255.255.255.0");

    when(sourceNatIp.getVlanTag()).thenReturn("111");

    when(ipAddressManager.assignSourceNatIpAddressToGuestNetwork(acc, network)).thenReturn(sourceNatIp);

    when(network.getGateway()).thenReturn(NETWORK_GATEWAY);

    when(network.getCidr()).thenReturn(NETWORK_CIDR);

    final CreateLogicalRouterAnswer answer = mock(CreateLogicalRouterAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentManager.easySend(eq(NICIRA_NVP_HOST_ID), (Command) any())).thenReturn(answer);

    assertTrue(element.implement(network, offering, dest, context));

}
@Before

public void setUp() throws ConfigurationException {

    element.resourceMgr = mock(ResourceManager.class);

    element.networkManager = networkManager;

    element.ntwkSrvcDao = ntwkSrvcDao;

    element.networkModel = networkModel;

    element.agentMgr = agentManager;

    element.hostDao = hostDao;

    element.niciraNvpDao = niciraNvpDao;

    element.niciraNvpRouterMappingDao = niciraNvpRouterMappingDao;

    element.vlanDao = vlanDao;

    element.ipAddrMgr = ipAddressManager;

    // Standard responses

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    element.configure("NiciraNvpTestElement", Collections.<String, Object>emptyMap());

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

@Before

public void setUp() throws ConfigurationException {

    element.resourceMgr = mock(ResourceManager.class);

    element.networkManager = networkManager;

    element.ntwkSrvcDao = ntwkSrvcDao;

    element.networkModel = networkModel;

    element.agentMgr = agentManager;

    element.hostDao = hostDao;

    element.niciraNvpDao = niciraNvpDao;

    element.niciraNvpRouterMappingDao = niciraNvpRouterMappingDao;

    element.vlanDao = vlanDao;

    element.ipAddrMgr = ipAddressManager;

    // Standard responses

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    element.configure("NiciraNvpTestElement", Collections.<String, Object>emptyMap());

}
@Test

public void implementSharedNetworkUuidVlanIdTest() throws URISyntaxException, ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException {

    // SHARED NETWORKS CASE 1: LOGICAL ROUTER'S UUID AS VLAN ID

    final Network network = mock(Network.class);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Lswitch);

    when(network.getBroadcastUri()).thenReturn(new URI("lswitch:aaaaa"));

    when(network.getId()).thenReturn(NETWORK_ID);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getGuestType()).thenReturn(GuestType.Shared);

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    when(ntwkSrvcDao.canProviderSupportServiceInNetwork(NETWORK_ID, Service.Connectivity, Provider.NiciraNvp)).thenReturn(true);

    final NiciraNvpDeviceVO device = mock(NiciraNvpDeviceVO.class);

    when(niciraNvpDao.listByPhysicalNetwork(NETWORK_ID)).thenReturn(Arrays.asList(new NiciraNvpDeviceVO[] { device }));

    when(device.getId()).thenReturn(1L);

    when(device.getHostId()).thenReturn(NICIRA_NVP_HOST_ID);

    HostVO niciraNvpHost = mock(HostVO.class);

    when(niciraNvpHost.getId()).thenReturn(NICIRA_NVP_HOST_ID);

    when(hostDao.findById(NICIRA_NVP_HOST_ID)).thenReturn(niciraNvpHost);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Shared);

    final DeployDestination dest = mock(DeployDestination.class);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext context = mock(ReservationContext.class);

    when(context.getDomain()).thenReturn(dom);

    when(context.getAccount()).thenReturn(acc);

    //SHARED NETWORKS CASE 1

    when(niciraNvpRouterMappingDao.existsMappingForNetworkId(NETWORK_ID)).thenReturn(true);

    when(network.getCidr()).thenReturn(NETWORK_CIDR);

    when(network.getGateway()).thenReturn(NETWORK_GATEWAY);

    NiciraNvpRouterMappingVO mapping = mock(NiciraNvpRouterMappingVO.class);

    when(mapping.getLogicalRouterUuid()).thenReturn("xxxx-xxxx-xxxx");

    when(niciraNvpRouterMappingDao.findByNetworkId(NETWORK_ID)).thenReturn(mapping);

    final ConfigureSharedNetworkUuidAnswer answer = mock(ConfigureSharedNetworkUuidAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentManager.easySend(eq(NICIRA_NVP_HOST_ID), (Command) any())).thenReturn(answer);

    assertTrue(element.implement(network, offering, dest, context));

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

@Before

public void setUp() throws ConfigurationException {

    element.resourceMgr = mock(ResourceManager.class);

    element.networkManager = networkManager;

    element.ntwkSrvcDao = ntwkSrvcDao;

    element.networkModel = networkModel;

    element.agentMgr = agentManager;

    element.hostDao = hostDao;

    element.niciraNvpDao = niciraNvpDao;

    element.niciraNvpRouterMappingDao = niciraNvpRouterMappingDao;

    element.vlanDao = vlanDao;

    element.ipAddrMgr = ipAddressManager;

    // Standard responses

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    element.configure("NiciraNvpTestElement", Collections.<String, Object>emptyMap());

}
@Test

public void implementSharedNetworkNumericalVlanIdTest() throws URISyntaxException, ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException {

    // SHARED NETWORKS CASE 2: NUMERICAL VLAN ID

    final Network network = mock(Network.class);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Lswitch);

    when(network.getBroadcastUri()).thenReturn(new URI("lswitch:aaaaa"));

    when(network.getId()).thenReturn(NETWORK_ID);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getGuestType()).thenReturn(GuestType.Shared);

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    when(ntwkSrvcDao.canProviderSupportServiceInNetwork(NETWORK_ID, Service.Connectivity, Provider.NiciraNvp)).thenReturn(true);

    final NiciraNvpDeviceVO device = mock(NiciraNvpDeviceVO.class);

    when(niciraNvpDao.listByPhysicalNetwork(NETWORK_ID)).thenReturn(Arrays.asList(new NiciraNvpDeviceVO[] { device }));

    when(device.getId()).thenReturn(1L);

    when(device.getHostId()).thenReturn(NICIRA_NVP_HOST_ID);

    HostVO niciraNvpHost = mock(HostVO.class);

    when(niciraNvpHost.getId()).thenReturn(NICIRA_NVP_HOST_ID);

    when(hostDao.findById(NICIRA_NVP_HOST_ID)).thenReturn(niciraNvpHost);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Shared);

    final DeployDestination dest = mock(DeployDestination.class);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext context = mock(ReservationContext.class);

    when(context.getDomain()).thenReturn(dom);

    when(context.getAccount()).thenReturn(acc);

    //SHARED NETWORKS CASE 2

    when(niciraNvpRouterMappingDao.existsMappingForNetworkId(NETWORK_ID)).thenReturn(false);

    VlanVO vlanVO = mock(VlanVO.class);

    when(vlanVO.getVlanTag()).thenReturn("111");

    when(vlanDao.listVlansByNetworkId(NETWORK_ID)).thenReturn(Arrays.asList(new VlanVO[] { vlanVO }));

    when(niciraNvpHost.getDetail("l2gatewayserviceuuid")).thenReturn("bbbb-bbbb-bbbb");

    final ConfigureSharedNetworkVlanIdAnswer answer = mock(ConfigureSharedNetworkVlanIdAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentManager.easySend(eq(NICIRA_NVP_HOST_ID), (Command) any())).thenReturn(answer);

    assertTrue(element.implement(network, offering, dest, context));

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

@Before

public void setUp() throws ConfigurationException {

    element.resourceMgr = mock(ResourceManager.class);

    element.networkManager = networkManager;

    element.ntwkSrvcDao = ntwkSrvcDao;

    element.networkModel = networkModel;

    element.agentMgr = agentManager;

    element.hostDao = hostDao;

    element.niciraNvpDao = niciraNvpDao;

    element.niciraNvpRouterMappingDao = niciraNvpRouterMappingDao;

    element.vlanDao = vlanDao;

    element.ipAddrMgr = ipAddressManager;

    // Standard responses

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    element.configure("NiciraNvpTestElement", Collections.<String, Object>emptyMap());

}
@Test(expected = CloudRuntimeException.class)

public void implementSharedNetworkNumericalVlanIdWithoutL2GatewayService() throws URISyntaxException, ConcurrentOperationException, ResourceUnavailableException, InsufficientCapacityException {

    final Network network = mock(Network.class);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Lswitch);

    when(network.getBroadcastUri()).thenReturn(new URI("lswitch:aaaaa"));

    when(network.getId()).thenReturn(NETWORK_ID);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getGuestType()).thenReturn(GuestType.Shared);

    when(networkModel.isProviderForNetwork(Provider.NiciraNvp, NETWORK_ID)).thenReturn(true);

    when(ntwkSrvcDao.canProviderSupportServiceInNetwork(NETWORK_ID, Service.Connectivity, Provider.NiciraNvp)).thenReturn(true);

    final NiciraNvpDeviceVO device = mock(NiciraNvpDeviceVO.class);

    when(niciraNvpDao.listByPhysicalNetwork(NETWORK_ID)).thenReturn(Arrays.asList(new NiciraNvpDeviceVO[] { device }));

    when(device.getId()).thenReturn(1L);

    when(device.getHostId()).thenReturn(NICIRA_NVP_HOST_ID);

    HostVO niciraNvpHost = mock(HostVO.class);

    when(niciraNvpHost.getId()).thenReturn(NICIRA_NVP_HOST_ID);

    when(hostDao.findById(NICIRA_NVP_HOST_ID)).thenReturn(niciraNvpHost);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Shared);

    final DeployDestination dest = mock(DeployDestination.class);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext context = mock(ReservationContext.class);

    when(context.getDomain()).thenReturn(dom);

    when(context.getAccount()).thenReturn(acc);

    //SHARED NETWORKS CASE 2

    when(niciraNvpRouterMappingDao.existsMappingForNetworkId(NETWORK_ID)).thenReturn(false);

    VlanVO vlanVO = mock(VlanVO.class);

    when(vlanVO.getVlanTag()).thenReturn("111");

    when(vlanDao.listVlansByNetworkId(NETWORK_ID)).thenReturn(Arrays.asList(new VlanVO[] { vlanVO }));

    when(niciraNvpHost.getDetail("l2gatewayserviceuuid")).thenReturn(null);

    element.implement(network, offering, dest, context);

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

/**

 * @param networks

 * @param offerings

 * @throws ConcurrentOperationException

 */

private void mockMgrs() throws ConcurrentOperationException {

    final Service service = Service.Connectivity;

    testNetwork.setState(Network.State.Implementing);

    testNetwork.setTrafficType(TrafficType.Guest);

    when(_networkMdl.isProviderEnabledInPhysicalNetwork(0L, "VirtualRouter")).thenReturn(true);

    when(_networkMdl.isProviderSupportServiceInNetwork(testNetwork.getId(), service, Network.Provider.VirtualRouter)).thenReturn(true);

    when(_networkMdl.isProviderForNetwork(Network.Provider.VirtualRouter, 0L)).thenReturn(true);

    when(testVMProfile.getType()).thenReturn(VirtualMachine.Type.User);

    when(testVMProfile.getHypervisorType()).thenReturn(HypervisorType.XenServer);

    final List<NetworkVO> networks = new ArrayList<NetworkVO>(1);

    networks.add(testNetwork);

    final List<NetworkOfferingVO> offerings = new ArrayList<NetworkOfferingVO>(1);

    offerings.add(testOffering);

    doReturn(offerings).when(_networkModel).getSystemAccountNetworkOfferings(NetworkOffering.SystemControlNetwork);

    doReturn(networks).when(_networkMgr).setupNetwork(any(Account.class), any(NetworkOffering.class), any(DeploymentPlan.class), any(String.class), any(String.class), anyBoolean());

    // being anti-social and testing my own case first

    doReturn(HypervisorType.XenServer).when(_resourceMgr).getDefaultHypervisor(anyLong());

    doReturn(new AccountVO()).when(_accountMgr).getAccount(testNetwork.getAccountId());

}
@Test

public void testCanHandle() {

    Network network = Mockito.mock(Network.class);

    final long networkId = 1;

    final long physicalNetworkId = 42;

    final long networkOfferingId = 10;

    final long dataCenterId = 33;

    when(network.getId()).thenReturn(networkId);

    lenient().when(network.getPhysicalNetworkId()).thenReturn(physicalNetworkId);

    lenient().when(network.getTrafficType()).thenReturn(TrafficType.Guest);

    lenient().when(network.getNetworkOfferingId()).thenReturn(networkOfferingId);

    lenient().when(network.getDataCenterId()).thenReturn(dataCenterId);

    when(network.getVpcId()).thenReturn(null);

    when(virtualRouterElement._networkMdl.getPhysicalNetworkId(network)).thenReturn(physicalNetworkId);

    when(virtualRouterElement._networkMdl.isProviderEnabledInPhysicalNetwork(physicalNetworkId, Network.Provider.VirtualRouter.getName())).thenReturn(true);

    when(virtualRouterElement._networkMdl.isProviderForNetwork(Network.Provider.VirtualRouter, networkId)).thenReturn(true);

    assertTrue(virtualRouterElement.canHandle(network, null));

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

/**

 * @param networks

 * @param offerings

 * @throws ConcurrentOperationException

 */

private void mockMgrs() throws ConcurrentOperationException {

    final Service service = Service.Connectivity;

    testNetwork.setState(Network.State.Implementing);

    testNetwork.setTrafficType(TrafficType.Guest);

    when(_networkMdl.isProviderEnabledInPhysicalNetwork(0L, "VirtualRouter")).thenReturn(true);

    when(_networkMdl.isProviderSupportServiceInNetwork(testNetwork.getId(), service, Network.Provider.VirtualRouter)).thenReturn(true);

    when(_networkMdl.isProviderForNetwork(Network.Provider.VirtualRouter, 0L)).thenReturn(true);

    when(testVMProfile.getType()).thenReturn(VirtualMachine.Type.User);

    when(testVMProfile.getHypervisorType()).thenReturn(HypervisorType.XenServer);

    final List<NetworkVO> networks = new ArrayList<NetworkVO>(1);

    networks.add(testNetwork);

    final List<NetworkOfferingVO> offerings = new ArrayList<NetworkOfferingVO>(1);

    offerings.add(testOffering);

    doReturn(offerings).when(_networkModel).getSystemAccountNetworkOfferings(NetworkOffering.SystemControlNetwork);

    doReturn(networks).when(_networkMgr).setupNetwork(any(Account.class), any(NetworkOffering.class), any(DeploymentPlan.class), any(String.class), any(String.class), anyBoolean());

    // being anti-social and testing my own case first

    doReturn(HypervisorType.XenServer).when(_resourceMgr).getDefaultHypervisor(anyLong());

    doReturn(new AccountVO()).when(_accountMgr).getAccount(testNetwork.getAccountId());

}
@Test

public void testAddPasswordAndUserdata() throws Exception {

    Network network = Mockito.mock(Network.class);

    VirtualMachineProfile vm = Mockito.mock(VirtualMachineProfile.class);

    NicProfile nic = Mockito.mock(NicProfile.class);

    DeployDestination dest = Mockito.mock(DeployDestination.class);

    ReservationContext context = Mockito.mock(ReservationContext.class);

    Service service = Service.UserData;

    final long networkId = 1;

    final long physicalNetworkId = 42;

    final long networkOfferingId = 10;

    final long dataCenterId = 33;

    when(network.getId()).thenReturn(networkId);

    lenient().when(network.getPhysicalNetworkId()).thenReturn(physicalNetworkId);

    lenient().when(network.getTrafficType()).thenReturn(TrafficType.Guest);

    lenient().when(network.getNetworkOfferingId()).thenReturn(networkOfferingId);

    lenient().when(network.getDataCenterId()).thenReturn(dataCenterId);

    when(network.getVpcId()).thenReturn(null);

    lenient().when(vm.getType()).thenReturn(VirtualMachine.Type.User);

    when(virtualRouterElement._networkMdl.getPhysicalNetworkId(network)).thenReturn(physicalNetworkId);

    when(virtualRouterElement._networkMdl.isProviderEnabledInPhysicalNetwork(physicalNetworkId, Network.Provider.VirtualRouter.getName())).thenReturn(true);

    when(virtualRouterElement._networkMdl.isProviderSupportServiceInNetwork(networkId, service, Network.Provider.VirtualRouter)).thenReturn(true);

    lenient().when(virtualRouterElement._dcDao.findById(dataCenterId)).thenReturn(Mockito.mock(DataCenterVO.class));

    when(virtualRouterElement.canHandle(network, service)).thenReturn(false);

    assertTrue(virtualRouterElement.addPasswordAndUserdata(network, nic, vm, dest, context));

}

public class MockNetworkModel {
    /**
     * Creates a mock NetworkModel and stubs isProviderForNetwork as specified.
     *
     * @param provider the Provider to check
     * @param networkId the network id
     * @param returnValue the boolean value to return from isProviderForNetwork
     * @return a configured mock NetworkModel
     */
    public static NetworkModel createMockNetworkModel(Network.Provider provider, long networkId, boolean returnValue) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.isProviderForNetwork(provider, networkId)).thenReturn(returnValue);
        return networkModel;
    }
}

@Test

public void applyFWRulesWithAddIngressRuleTest() throws ResourceUnavailableException {

    Network network = mock(Network.class);

    FirewallRuleVO firewallRuleVO = mock(FirewallRuleVO.class);

    Network publicNetwork = mock(Network.class);

    TungstenAnswer createNetworkPolicyAnswer = mock(TungstenAnswer.class);

    TungstenAnswer applyNetworkPolicyAnswer = mock(TungstenAnswer.class);

    IPAddressVO ipAddressVO = mock(IPAddressVO.class);

    Ip ip = mock(Ip.class);

    when(firewallRuleVO.getState()).thenReturn(FirewallRule.State.Add);

    when(firewallRuleVO.getSourceCidrList()).thenReturn(List.of("192.168.100.0/24"));

    when(firewallRuleVO.getProtocol()).thenReturn(NetUtils.ALL_PROTO);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);

    when(ipAddressDao.findById(anyLong())).thenReturn(ipAddressVO);

    when(ipAddressVO.getAddress()).thenReturn(ip);

    when(firewallRuleVO.getPurpose()).thenReturn(FirewallRule.Purpose.Firewall);

    when(firewallRuleVO.getTrafficType()).thenReturn(FirewallRule.TrafficType.Ingress);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(createNetworkPolicyAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(ApplyTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(applyNetworkPolicyAnswer);

    when(createNetworkPolicyAnswer.getResult()).thenReturn(true);

    when(applyNetworkPolicyAnswer.getResult()).thenReturn(true);

    assertTrue(tungstenElement.applyFWRules(network, List.of(firewallRuleVO)));

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network publicNetwork) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);
        return networkModel;
    }
}

@Test

public void removePublicNetworkSubnetTest() {

    VlanVO vlanVO = mock(VlanVO.class);

    Network publicNetwork = mock(Network.class);

    TungstenAnswer deleteTungstenNetworkPolicyAnswer = mock(TungstenAnswer.class);

    TungstenAnswer removeTungstenNetworkSubnetAnswer = mock(TungstenAnswer.class);

    TungstenAnswer getTungstenNetworkDnsAnswer = mock(TungstenAnswer.class);

    IPAddressVO ipAddressVO = mock(IPAddressVO.class);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(deleteTungstenNetworkPolicyAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(RemoveTungstenNetworkSubnetCommand.class), anyLong())).thenReturn(removeTungstenNetworkSubnetAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(GetTungstenNetworkDnsCommand.class), anyLong())).thenReturn(getTungstenNetworkDnsAnswer);

    when(deleteTungstenNetworkPolicyAnswer.getResult()).thenReturn(true);

    when(removeTungstenNetworkSubnetAnswer.getResult()).thenReturn(true);

    when(getTungstenNetworkDnsAnswer.getResult()).thenReturn(true);

    when(getTungstenNetworkDnsAnswer.getDetails()).thenReturn("192.168.100.150");

    when(publicNetwork.getTrafficType()).thenReturn(Networks.TrafficType.Public);

    when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);

    assertTrue(tungstenService.removePublicNetworkSubnet(vlanVO));

    verify(ipAddressDao, times(1)).unassignIpAddress(anyLong());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network publicNetwork) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);
        return networkModel;
    }
}

@Test

public void applyFWRulesWithRevokeRuleTest() throws ResourceUnavailableException {

    Network network = mock(Network.class);

    FirewallRuleVO firewallRuleVO = mock(FirewallRuleVO.class);

    Network publicNetwork = mock(Network.class);

    TungstenAnswer deleteNetworkPolicyAnswer = mock(TungstenAnswer.class);

    when(firewallRuleVO.getState()).thenReturn(FirewallRule.State.Revoke);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);

    when(firewallRuleVO.getPurpose()).thenReturn(FirewallRule.Purpose.Firewall);

    when(firewallRuleVO.getTrafficType()).thenReturn(FirewallRule.TrafficType.Ingress);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(deleteNetworkPolicyAnswer);

    when(deleteNetworkPolicyAnswer.getResult()).thenReturn(true);

    assertTrue(tungstenElement.applyFWRules(network, List.of(firewallRuleVO)));

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network publicNetwork) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);
        return networkModel;
    }
}

@Test

public void updateLoadBalancerTest() {

    Network network = mock(Network.class);

    LoadBalancingRule loadBalancingRule = mock(LoadBalancingRule.class);

    Network publicNetwork = mock(Network.class);

    IPAddressVO ipAddressVO = mock(IPAddressVO.class);

    HostVO hostVO = mock(HostVO.class);

    TungstenAnswer getTungstenLoadBalancerAnswer = mock(TungstenAnswer.class);

    TungstenAnswer updateLoadBalancerServiceInstanceAnswer = mock(TungstenAnswer.class);

    Answer updateTungstenLoadbalancerStatsAnswer = mock(Answer.class);

    Answer updateTungstenLoadbalancerSslAnswer = mock(Answer.class);

    FirewallRuleVO firewallRuleVO = mock(FirewallRuleVO.class);

    LoadBalancerCertMapVO loadBalancerCertMapVO = mock(LoadBalancerCertMapVO.class);

    SslCertVO sslCertVO = mock(SslCertVO.class);

    TungstenGuestNetworkIpAddressVO tungstenGuestNetworkIpAddressVO = mock(TungstenGuestNetworkIpAddressVO.class);

    Ip ip = mock(Ip.class);

    AccountVO accountVO = mock(AccountVO.class);

    Loadbalancer loadbalancer = mock(Loadbalancer.class);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);

    when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);

    when(hostDao.listAllHostsByZoneAndHypervisorType(anyLong(), eq(Hypervisor.HypervisorType.KVM))).thenReturn(List.of(hostVO));

    when(tungstenFabricUtils.sendTungstenCommand(any(GetTungstenLoadBalancerCommand.class), anyLong())).thenReturn(getTungstenLoadBalancerAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(UpdateLoadBalancerServiceInstanceCommand.class), anyLong())).thenReturn(updateLoadBalancerServiceInstanceAnswer);

    when(agentMgr.easySend(anyLong(), any(UpdateTungstenLoadbalancerStatsCommand.class))).thenReturn(updateTungstenLoadbalancerStatsAnswer);

    when(agentMgr.easySend(anyLong(), any(UpdateTungstenLoadbalancerSslCommand.class))).thenReturn(updateTungstenLoadbalancerSslAnswer);

    when(getTungstenLoadBalancerAnswer.getResult()).thenReturn(true);

    when(updateLoadBalancerServiceInstanceAnswer.getResult()).thenReturn(true);

    when(updateTungstenLoadbalancerStatsAnswer.getResult()).thenReturn(true);

    when(updateTungstenLoadbalancerSslAnswer.getResult()).thenReturn(true);

    when(configDao.getValue(Config.NetworkLBHaproxyStatsVisbility.key())).thenReturn("enabled");

    when(fwRulesDao.listByIpAndPurposeAndNotRevoked(anyLong(), eq(FirewallRule.Purpose.LoadBalancing))).thenReturn(List.of(firewallRuleVO));

    when(lbCertMapDao.findByLbRuleId(anyLong())).thenReturn(loadBalancerCertMapVO);

    when(entityMgr.findById(eq(SslCertVO.class), anyLong())).thenReturn(sslCertVO);

    when(tungstenGuestNetworkIpAddressDao.findByNetworkIdAndPublicIp(anyLong(), anyString())).thenReturn(tungstenGuestNetworkIpAddressVO);

    when(loadBalancingRule.getSourceIp()).thenReturn(ip);

    when(accountDao.findById(anyLong())).thenReturn(accountVO);

    when(ip.addr()).thenReturn("192.168.100.100");

    when(getTungstenLoadBalancerAnswer.getApiObjectBase()).thenReturn(loadbalancer);

    when(ipAddressVO.getAddress()).thenReturn(ip);

    when(tungstenGuestNetworkIpAddressVO.getGuestIpAddress()).thenReturn(ip);

    assertTrue(tungstenService.updateLoadBalancer(network, loadBalancingRule));

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network publicNetwork) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);
        return networkModel;
    }
}

@Test

public void createPublicNetworkTest() {

    Network publicNetwork = mock(Network.class);

    VirtualNetwork virtualNetwork = mock(VirtualNetwork.class);

    NetworkDetailVO networkDetailVO = mock(NetworkDetailVO.class);

    NetworkPolicy networkPolicy = mock(NetworkPolicy.class);

    TungstenAnswer createPublicNetworkAnswer = mock(TungstenAnswer.class);

    TungstenAnswer createFloatingIpPoolAnswer = mock(TungstenAnswer.class);

    TungstenAnswer createTungstenPolicyAnswer = mock(TungstenAnswer.class);

    TungstenAnswer applyTungstenPolicyAnswer = mock(TungstenAnswer.class);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenNetworkCommand.class), anyLong())).thenReturn(createPublicNetworkAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenFloatingIpPoolCommand.class), anyLong())).thenReturn(createFloatingIpPoolAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(createTungstenPolicyAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(ApplyTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(applyTungstenPolicyAnswer);

    when(createPublicNetworkAnswer.getResult()).thenReturn(true);

    when(createFloatingIpPoolAnswer.getResult()).thenReturn(true);

    when(createTungstenPolicyAnswer.getResult()).thenReturn(true);

    when(applyTungstenPolicyAnswer.getResult()).thenReturn(true);

    when(createPublicNetworkAnswer.getApiObjectBase()).thenReturn(virtualNetwork);

    when(createTungstenPolicyAnswer.getApiObjectBase()).thenReturn(networkPolicy);

    when(networkDetailsDao.persist(any(NetworkDetailVO.class))).thenReturn(networkDetailVO);

    when(virtualNetwork.getQualifiedName()).thenReturn(Arrays.asList("default-domain", "default-project", "publicNetwork"));

    assertTrue(tungstenService.createPublicNetwork(1L));

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network publicNetwork) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);
        return networkModel;
    }
}

@Test

public void shutdownProviderInstancesTest() throws ConcurrentOperationException {

    PhysicalNetworkServiceProvider physicalNetworkServiceProvider = mock(PhysicalNetworkServiceProvider.class);

    ReservationContext reservationContext = mock(ReservationContext.class);

    PhysicalNetworkVO physicalNetworkVO = mock(PhysicalNetworkVO.class);

    TungstenProviderVO tungstenProviderVO = mock(TungstenProviderVO.class);

    DataCenterVO dataCenterVO = mock(DataCenterVO.class);

    Network publicNetwork = mock(Network.class);

    VlanVO vlanVO1 = mock(VlanVO.class);

    VlanVO vlanVO2 = mock(VlanVO.class);

    List<VlanVO> vlanVOList = Arrays.asList(vlanVO1, vlanVO2);

    HostPodVO hostPodVO1 = mock(HostPodVO.class);

    HostPodVO hostPodVO2 = mock(HostPodVO.class);

    List<HostPodVO> hostPodVOList = Arrays.asList(hostPodVO1, hostPodVO2);

    when(physicalNetworkDao.findById(anyLong())).thenReturn(physicalNetworkVO);

    when(tungstenProviderDao.findByZoneId(anyLong())).thenReturn(tungstenProviderVO);

    when(dataCenterDao.findById(anyLong())).thenReturn(dataCenterVO);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);

    when(vlanDao.listVlansByNetworkIdIncludingRemoved(anyLong())).thenReturn(vlanVOList);

    when(hostPodDao.listByDataCenterId(anyLong())).thenReturn(hostPodVOList);

    assertTrue(tungstenElement.shutdownProviderInstances(physicalNetworkServiceProvider, reservationContext));

    verify(networkServiceMapDao, times(1)).deleteByNetworkId(anyLong());

    verify(tungstenService, times(2)).removePublicNetworkSubnet(any(VlanVO.class));

    verify(tungstenService, times(1)).deletePublicNetwork(anyLong());

    verify(tungstenService, times(2)).removeManagementNetworkSubnet(any(HostPodVO.class));

    verify(tungstenService, times(1)).deleteManagementNetwork(anyLong());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network publicNetwork) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);
        return networkModel;
    }
}

@Test

public void addPublicNetworkSubnetTest() {

    VlanVO vlanVO = mock(VlanVO.class);

    Network publicNetwork = mock(Network.class);

    TungstenAnswer addTungstenNetworkSubnetAnswer = mock(TungstenAnswer.class);

    TungstenAnswer createTungstenPolicyAnswer = mock(TungstenAnswer.class);

    TungstenAnswer applyTungstenPolicyAnswer = mock(TungstenAnswer.class);

    NetworkPolicy networkPolicy = mock(NetworkPolicy.class);

    TungstenAnswer getTungstenNetworkDnsAnswer = mock(TungstenAnswer.class);

    IPAddressVO ipAddressVO = mock(IPAddressVO.class);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);

    when(tungstenFabricUtils.sendTungstenCommand(any(AddTungstenNetworkSubnetCommand.class), anyLong())).thenReturn(addTungstenNetworkSubnetAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(createTungstenPolicyAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(ApplyTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(applyTungstenPolicyAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(GetTungstenNetworkDnsCommand.class), anyLong())).thenReturn(getTungstenNetworkDnsAnswer);

    when(getTungstenNetworkDnsAnswer.getDetails()).thenReturn("192.168.100.150");

    when(vlanVO.getIpRange()).thenReturn("192.168.100.100-192.168.100.200");

    when(vlanVO.getVlanGateway()).thenReturn("192.168.100.1");

    when(vlanVO.getVlanNetmask()).thenReturn("255.255.255.0");

    when(publicNetwork.getCidr()).thenReturn("192.168.100.0/24");

    when(addTungstenNetworkSubnetAnswer.getResult()).thenReturn(true);

    when(getTungstenNetworkDnsAnswer.getResult()).thenReturn(true);

    when(addTungstenNetworkSubnetAnswer.getResult()).thenReturn(true);

    when(createTungstenPolicyAnswer.getResult()).thenReturn(true);

    when(applyTungstenPolicyAnswer.getResult()).thenReturn(true);

    when(publicNetwork.getTrafficType()).thenReturn(Networks.TrafficType.Public);

    when(createTungstenPolicyAnswer.getApiObjectBase()).thenReturn(networkPolicy);

    when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);

    when(ipAddressDao.mark(anyLong(), any(Ip.class))).thenReturn(true);

    assertTrue(tungstenService.addPublicNetworkSubnet(vlanVO));

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network publicNetwork) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);
        return networkModel;
    }
}

@Test

public void applyFWRulesWithAddEgressRuleTest() throws ResourceUnavailableException {

    Network network = mock(Network.class);

    FirewallRuleVO firewallRuleVO = mock(FirewallRuleVO.class);

    Network publicNetwork = mock(Network.class);

    TungstenAnswer createNetworkPolicyAnswer = mock(TungstenAnswer.class);

    TungstenAnswer applyNetworkPolicyAnswer = mock(TungstenAnswer.class);

    when(firewallRuleVO.getState()).thenReturn(FirewallRule.State.Add);

    when(firewallRuleVO.getSourceCidrList()).thenReturn(List.of("192.168.100.0/24"));

    when(firewallRuleVO.getProtocol()).thenReturn(NetUtils.ALL_PROTO);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);

    when(firewallRuleVO.getPurpose()).thenReturn(FirewallRule.Purpose.Firewall);

    when(firewallRuleVO.getTrafficType()).thenReturn(FirewallRule.TrafficType.Egress);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(createNetworkPolicyAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(ApplyTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(applyNetworkPolicyAnswer);

    when(createNetworkPolicyAnswer.getResult()).thenReturn(true);

    when(applyNetworkPolicyAnswer.getResult()).thenReturn(true);

    assertTrue(tungstenElement.applyFWRules(network, List.of(firewallRuleVO)));

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network publicNetwork) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);
        return networkModel;
    }
}

@Test

public void deletePublicNetworkTest() {

    Network publicNetwork = mock(Network.class);

    TungstenAnswer deleteTungstenNetworkPolicyAnswer = mock(TungstenAnswer.class);

    TungstenAnswer deleteTungstenFloatingIpPoolAnswer = mock(TungstenAnswer.class);

    TungstenAnswer deleteTungstenNetworkAnswer = mock(TungstenAnswer.class);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(deleteTungstenNetworkPolicyAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenFloatingIpPoolCommand.class), anyLong())).thenReturn(deleteTungstenFloatingIpPoolAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkCommand.class), anyLong())).thenReturn(deleteTungstenNetworkAnswer);

    when(deleteTungstenNetworkPolicyAnswer.getResult()).thenReturn(true);

    when(deleteTungstenFloatingIpPoolAnswer.getResult()).thenReturn(true);

    when(deleteTungstenNetworkAnswer.getResult()).thenReturn(true);

    assertTrue(tungstenService.deletePublicNetwork(1L));

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network publicNetwork) {
        NetworkModel networkModel = mock(NetworkModel.class);
        when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), eq(Networks.TrafficType.Public))).thenReturn(publicNetwork);
        return networkModel;
    }
}

@Test

public void testImplement() throws InsufficientVirtualNetworkCapacityException, URISyntaxException {

    final PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById((Long) any())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "VCS" }));

    when(physnet.getId()).thenReturn(NETWORK_ID);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    when(nosd.areServicesSupportedByNetworkOffering(NETWORK_ID, Service.Connectivity)).thenReturn(true);

    mock(DeploymentPlan.class);

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getBroadcastUri()).thenReturn(new URI("vlan://14"));

    final DeployDestination dest = mock(DeployDestination.class);

    final DataCenter dc = mock(DataCenter.class);

    when(dest.getDataCenter()).thenReturn(dc);

    final HostVO brocadeHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(brocadeHost);

    when(brocadeHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final BrocadeVcsDeviceVO brocadeDevice = mock(BrocadeVcsDeviceVO.class);

    when(brocadeDevice.getHostId()).thenReturn(NETWORK_ID);

    List<BrocadeVcsDeviceVO> devices = new ArrayList();

    devices.add(brocadeDevice);

    when(vcsdao.listByPhysicalNetwork(anyLong())).thenReturn(devices);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    when(guestGuru.implement(network, offering, dest, res)).thenReturn(network);

    final CreateNetworkAnswer answer = mock(CreateNetworkAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    final Network implementednetwork = guru.implement(network, offering, dest, res);

    assertTrue(implementednetwork != null);

    verify(agentmgr, times(1)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testImplementFail() throws InsufficientVirtualNetworkCapacityException, URISyntaxException {

    final PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById((Long) any())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "VCS" }));

    when(physnet.getId()).thenReturn(NETWORK_ID);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    when(nosd.areServicesSupportedByNetworkOffering(NETWORK_ID, Service.Connectivity)).thenReturn(false);

    mock(DeploymentPlan.class);

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getBroadcastUri()).thenReturn(new URI("vlan://14"));

    final DeployDestination dest = mock(DeployDestination.class);

    final DataCenter dc = mock(DataCenter.class);

    when(dest.getDataCenter()).thenReturn(dc);

    final HostVO brocadeHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(brocadeHost);

    when(brocadeHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final BrocadeVcsDeviceVO brocadeDevice = mock(BrocadeVcsDeviceVO.class);

    when(brocadeDevice.getHostId()).thenReturn(NETWORK_ID);

    final List<BrocadeVcsDeviceVO> devices = mock(List.class);

    when(devices.isEmpty()).thenReturn(true);

    when(vcsdao.listByPhysicalNetwork(anyLong())).thenReturn(devices);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    when(guestGuru.implement(network, offering, dest, res)).thenReturn(network);

    final CreateNetworkAnswer answer = mock(CreateNetworkAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    final Network implementednetwork = guru.implement(network, offering, dest, res);

    assertTrue(implementednetwork == null);

    verify(agentmgr, times(0)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testReserve() throws InsufficientVirtualNetworkCapacityException, URISyntaxException, InsufficientAddressCapacityException {

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getBroadcastUri()).thenReturn(new URI("vlan://14"));

    when(network.getDataCenterId()).thenReturn(NETWORK_ID);

    final NicProfile nic = mock(NicProfile.class);

    when(nic.getMacAddress()).thenReturn("macaddress");

    when(nic.getReservationStrategy()).thenReturn(ReservationStrategy.Start);

    final VirtualMachineProfile vmProfile = mock(VirtualMachineProfile.class);

    final DeployDestination dest = mock(DeployDestination.class);

    final DataCenterVO dc = mock(DataCenterVO.class);

    when(dest.getDataCenter()).thenReturn(dc);

    when(dcdao.findById((long) anyInt())).thenReturn(dc);

    final HostVO brocadeHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(brocadeHost);

    when(brocadeHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final BrocadeVcsDeviceVO brocadeDevice = mock(BrocadeVcsDeviceVO.class);

    when(brocadeDevice.getHostId()).thenReturn(NETWORK_ID);

    List<BrocadeVcsDeviceVO> devices = new ArrayList();

    devices.add(brocadeDevice);

    when(vcsdao.listByPhysicalNetwork(anyLong())).thenReturn(devices);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    final AssociateMacToNetworkAnswer answer = mock(AssociateMacToNetworkAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    guru.reserve(nic, network, vmProfile, dest, res);

    verify(agentmgr, times(1)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testReserveFail() throws InsufficientVirtualNetworkCapacityException, URISyntaxException, InsufficientAddressCapacityException {

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getBroadcastUri()).thenReturn(new URI("vlan://14"));

    when(network.getDataCenterId()).thenReturn(NETWORK_ID);

    final NicProfile nic = mock(NicProfile.class);

    when(nic.getMacAddress()).thenReturn("macaddress");

    when(nic.getReservationStrategy()).thenReturn(ReservationStrategy.Start);

    final VirtualMachineProfile vmProfile = mock(VirtualMachineProfile.class);

    final DeployDestination dest = mock(DeployDestination.class);

    final DataCenterVO dc = mock(DataCenterVO.class);

    when(dest.getDataCenter()).thenReturn(dc);

    when(dcdao.findById((long) anyInt())).thenReturn(dc);

    final HostVO brocadeHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(brocadeHost);

    when(brocadeHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final BrocadeVcsDeviceVO brocadeDevice = mock(BrocadeVcsDeviceVO.class);

    when(brocadeDevice.getHostId()).thenReturn(NETWORK_ID);

    final List<BrocadeVcsDeviceVO> devices = mock(List.class);

    when(devices.isEmpty()).thenReturn(true);

    when(vcsdao.listByPhysicalNetwork(anyLong())).thenReturn(devices);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    final AssociateMacToNetworkAnswer answer = mock(AssociateMacToNetworkAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    guru.reserve(nic, network, vmProfile, dest, res);

    verify(agentmgr, times(0)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testDeallocate() {

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getDataCenterId()).thenReturn(NETWORK_ID);

    final NicProfile nic = mock(NicProfile.class);

    when(nic.getMacAddress()).thenReturn("macaddress");

    when(nic.getReservationStrategy()).thenReturn(ReservationStrategy.Start);

    final VirtualMachineProfile vmProfile = mock(VirtualMachineProfile.class);

    final HostVO brocadeHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(brocadeHost);

    when(brocadeHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final BrocadeVcsDeviceVO brocadeDevice = mock(BrocadeVcsDeviceVO.class);

    when(brocadeDevice.getHostId()).thenReturn(NETWORK_ID);

    final List<BrocadeVcsDeviceVO> devices = new ArrayList();

    devices.add(brocadeDevice);

    when(vcsdao.listByPhysicalNetwork(anyLong())).thenReturn(devices);

    final DisassociateMacFromNetworkAnswer answer = mock(DisassociateMacFromNetworkAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    guru.deallocate(network, nic, vmProfile);

    verify(agentmgr, times(1)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testDeallocateFail() {

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(network.getDataCenterId()).thenReturn(NETWORK_ID);

    final NicProfile nic = mock(NicProfile.class);

    when(nic.getMacAddress()).thenReturn("macaddress");

    when(nic.getReservationStrategy()).thenReturn(ReservationStrategy.Start);

    final VirtualMachineProfile vmProfile = mock(VirtualMachineProfile.class);

    final HostVO brocadeHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(brocadeHost);

    when(brocadeHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final BrocadeVcsDeviceVO brocadeDevice = mock(BrocadeVcsDeviceVO.class);

    when(brocadeDevice.getHostId()).thenReturn(NETWORK_ID);

    final List<BrocadeVcsDeviceVO> devices = mock(List.class);

    when(devices.isEmpty()).thenReturn(true);

    when(vcsdao.listByPhysicalNetwork(anyLong())).thenReturn(devices);

    final DisassociateMacFromNetworkAnswer answer = mock(DisassociateMacFromNetworkAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    guru.deallocate(network, nic, vmProfile);

    verify(agentmgr, times(0)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testTrash() {

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getId()).thenReturn(NETWORK_ID);

    when(network.getDataCenterId()).thenReturn(NETWORK_ID);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    final HostVO brocadeHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(brocadeHost);

    when(brocadeHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final BrocadeVcsNetworkVlanMappingVO mapping = mock(BrocadeVcsNetworkVlanMappingVO.class);

    when(mapping.getVlanId()).thenReturn(14);

    when(vcsmapdao.findByNetworkId(anyLong())).thenReturn(mapping);

    final BrocadeVcsDeviceVO brocadeDevice = mock(BrocadeVcsDeviceVO.class);

    when(brocadeDevice.getHostId()).thenReturn(NETWORK_ID);

    final List<BrocadeVcsDeviceVO> devices = new ArrayList();

    devices.add(brocadeDevice);

    when(vcsdao.listByPhysicalNetwork(anyLong())).thenReturn(devices);

    final DeleteNetworkAnswer answer = mock(DeleteNetworkAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    when(vcsdao.remove((long) anyInt())).thenReturn(true);

    final boolean result = guru.trash(network, offering);

    assertTrue(result == true);

    verify(agentmgr, times(1)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testTrashFail() {

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getId()).thenReturn(NETWORK_ID);

    when(network.getDataCenterId()).thenReturn(NETWORK_ID);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    final HostVO brocadeHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(brocadeHost);

    when(brocadeHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final BrocadeVcsNetworkVlanMappingVO mapping = mock(BrocadeVcsNetworkVlanMappingVO.class);

    when(mapping.getVlanId()).thenReturn(14);

    when(vcsmapdao.findByNetworkId(anyLong())).thenReturn(mapping);

    when(vcsmapdao.remove(anyLong())).thenReturn(true);

    final BrocadeVcsDeviceVO brocadeDevice = mock(BrocadeVcsDeviceVO.class);

    when(brocadeDevice.getHostId()).thenReturn(NETWORK_ID);

    final List<BrocadeVcsDeviceVO> devices = mock(List.class);

    when(devices.isEmpty()).thenReturn(true);

    when(vcsdao.listByPhysicalNetwork(anyLong())).thenReturn(devices);

    final boolean result = guru.trash(network, offering);

    assertTrue(result == false);

    verify(agentmgr, times(0)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testImplement() throws InsufficientVirtualNetworkCapacityException {

    final PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById((Long) any())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "STT", "VXLAN" }));

    when(physnet.getId()).thenReturn(NETWORK_ID);

    final NiciraNvpDeviceVO device = mock(NiciraNvpDeviceVO.class);

    when(nvpdao.listByPhysicalNetwork(NETWORK_ID)).thenReturn(Arrays.asList(new NiciraNvpDeviceVO[] { device }));

    when(device.getId()).thenReturn(1L);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    when(nosd.areServicesSupportedByNetworkOffering(NETWORK_ID, Service.Connectivity)).thenReturn(false);

    mock(DeploymentPlan.class);

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    final DeployDestination dest = mock(DeployDestination.class);

    final DataCenter dc = mock(DataCenter.class);

    when(dest.getDataCenter()).thenReturn(dc);

    final HostVO niciraHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(niciraHost);

    when(niciraHost.getDetail("transportzoneuuid")).thenReturn("aaaa");

    when(niciraHost.getDetail("transportzoneisotype")).thenReturn("stt");

    when(niciraHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    final CreateLogicalSwitchAnswer answer = mock(CreateLogicalSwitchAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(answer.getLogicalSwitchUuid()).thenReturn("aaaaa");

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    final Network implementednetwork = guru.implement(network, offering, dest, res);

    assertTrue(implementednetwork != null);

    verify(agentmgr, times(1)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testImplementWithCidr() throws InsufficientVirtualNetworkCapacityException {

    final PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById((Long) any())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "STT" }));

    when(physnet.getId()).thenReturn(NETWORK_ID);

    final NiciraNvpDeviceVO device = mock(NiciraNvpDeviceVO.class);

    when(nvpdao.listByPhysicalNetwork(NETWORK_ID)).thenReturn(Arrays.asList(new NiciraNvpDeviceVO[] { device }));

    when(device.getId()).thenReturn(1L);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    when(nosd.areServicesSupportedByNetworkOffering(NETWORK_ID, Service.Connectivity)).thenReturn(false);

    mock(DeploymentPlan.class);

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getGateway()).thenReturn("10.1.1.1");

    when(network.getCidr()).thenReturn("10.1.1.0/24");

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    final DeployDestination dest = mock(DeployDestination.class);

    final DataCenter dc = mock(DataCenter.class);

    when(dest.getDataCenter()).thenReturn(dc);

    final HostVO niciraHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(niciraHost);

    when(niciraHost.getDetail("transportzoneuuid")).thenReturn("aaaa");

    when(niciraHost.getDetail("transportzoneisotype")).thenReturn("stt");

    when(niciraHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    final CreateLogicalSwitchAnswer answer = mock(CreateLogicalSwitchAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(answer.getLogicalSwitchUuid()).thenReturn("aaaaa");

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    final Network implementednetwork = guru.implement(network, offering, dest, res);

    assertTrue(implementednetwork != null);

    assertTrue(implementednetwork.getCidr().equals("10.1.1.0/24"));

    assertTrue(implementednetwork.getGateway().equals("10.1.1.1"));

    verify(agentmgr, times(1)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testImplementURIException() throws InsufficientVirtualNetworkCapacityException {

    final PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById((Long) any())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "STT" }));

    when(physnet.getId()).thenReturn(NETWORK_ID);

    final NiciraNvpDeviceVO device = mock(NiciraNvpDeviceVO.class);

    when(nvpdao.listByPhysicalNetwork(NETWORK_ID)).thenReturn(Arrays.asList(new NiciraNvpDeviceVO[] { device }));

    when(device.getId()).thenReturn(1L);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    when(nosd.areServicesSupportedByNetworkOffering(NETWORK_ID, Service.Connectivity)).thenReturn(false);

    mock(DeploymentPlan.class);

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    final DeployDestination dest = mock(DeployDestination.class);

    final DataCenter dc = mock(DataCenter.class);

    when(dest.getDataCenter()).thenReturn(dc);

    final HostVO niciraHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(niciraHost);

    when(niciraHost.getDetail("transportzoneuuid")).thenReturn("aaaa");

    when(niciraHost.getDetail("transportzoneisotype")).thenReturn("stt");

    when(niciraHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    final CreateLogicalSwitchAnswer answer = mock(CreateLogicalSwitchAnswer.class);

    when(answer.getResult()).thenReturn(true);

    //when(answer.getLogicalSwitchUuid()).thenReturn("aaaaa");

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    final Network implementednetwork = guru.implement(network, offering, dest, res);

    assertTrue(implementednetwork == null);

    verify(agentmgr, times(1)).easySend(eq(NETWORK_ID), (Command) any());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testShutdown() throws InsufficientVirtualNetworkCapacityException, URISyntaxException {

    final PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById((Long) any())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "STT", "VXLAN" }));

    when(physnet.getId()).thenReturn(NETWORK_ID);

    final NiciraNvpDeviceVO device = mock(NiciraNvpDeviceVO.class);

    when(nvpdao.listByPhysicalNetwork(NETWORK_ID)).thenReturn(Arrays.asList(new NiciraNvpDeviceVO[] { device }));

    when(device.getId()).thenReturn(1L);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    when(nosd.areServicesSupportedByNetworkOffering(NETWORK_ID, Service.Connectivity)).thenReturn(false);

    mock(DeploymentPlan.class);

    final NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Lswitch);

    when(network.getBroadcastUri()).thenReturn(new URI("lswitch:aaaaa"));

    when(network.getPhysicalNetworkId()).thenReturn(NETWORK_ID);

    when(netdao.findById(NETWORK_ID)).thenReturn(network);

    final DeployDestination dest = mock(DeployDestination.class);

    final DataCenter dc = mock(DataCenter.class);

    when(dest.getDataCenter()).thenReturn(dc);

    final HostVO niciraHost = mock(HostVO.class);

    when(hostdao.findById(anyLong())).thenReturn(niciraHost);

    when(niciraHost.getDetail("transportzoneuuid")).thenReturn("aaaa");

    when(niciraHost.getDetail("transportzoneisotype")).thenReturn("stt");

    when(niciraHost.getId()).thenReturn(NETWORK_ID);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(NETWORK_ID);

    final Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    final Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    final ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    final DeleteLogicalSwitchAnswer answer = mock(DeleteLogicalSwitchAnswer.class);

    when(answer.getResult()).thenReturn(true);

    when(agentmgr.easySend(eq(NETWORK_ID), (Command) any())).thenReturn(answer);

    final NetworkProfile implementednetwork = mock(NetworkProfile.class);

    when(implementednetwork.getId()).thenReturn(NETWORK_ID);

    when(implementednetwork.getBroadcastUri()).thenReturn(new URI("lswitch:aaaa"));

    when(offering.isSpecifyVlan()).thenReturn(false);

    guru.shutdown(implementednetwork, offering);

    verify(agentmgr, times(1)).easySend(eq(NETWORK_ID), (Command) any());

    verify(implementednetwork, times(1)).setBroadcastUri(null);

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testImplement() throws InsufficientVirtualNetworkCapacityException {

    PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById(anyLong())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "VXLAN" }));

    when(physnet.getId()).thenReturn(42L);

    NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(42L);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getPhysicalNetworkId()).thenReturn(42L);

    DeployDestination dest = mock(DeployDestination.class);

    DataCenter dc = mock(DataCenter.class);

    when(dest.getDataCenter()).thenReturn(dc);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L);

    //TODO(VXLAN): doesn't support VNI specified

    //when(confsvr.getConfigValue((String) any(), (String) any(), anyLong())).thenReturn("true");

    when(dcdao.allocateVnet(anyLong(), anyLong(), anyLong(), (String) any(), eq(true))).thenReturn("42");

    doNothing().when(guru).allocateVnetComplete((Network) any(), (NetworkVO) any(), anyLong(), anyLong(), (String) any(), eq("42"));

    Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    Network implementednetwork = guru.implement(network, offering, dest, res);

    assertTrue(implementednetwork != null);

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testImplementWithCidr() throws InsufficientVirtualNetworkCapacityException {

    PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById(anyLong())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "VXLAN" }));

    when(physnet.getId()).thenReturn(42L);

    NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(42L);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getGateway()).thenReturn("10.1.1.1");

    when(network.getCidr()).thenReturn("10.1.1.0/24");

    when(network.getPhysicalNetworkId()).thenReturn(42L);

    DeployDestination dest = mock(DeployDestination.class);

    DataCenter dc = mock(DataCenter.class);

    when(dest.getDataCenter()).thenReturn(dc);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L);

    //TODO(VXLAN): doesn't support VNI specified

    //when(confsvr.getConfigValue((String) any(), (String) any(), anyLong())).thenReturn("true");

    when(dcdao.allocateVnet(anyLong(), anyLong(), anyLong(), (String) any(), eq(true))).thenReturn("42");

    doNothing().when(guru).allocateVnetComplete((Network) any(), (NetworkVO) any(), anyLong(), anyLong(), (String) any(), eq("42"));

    Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    Network implementednetwork = guru.implement(network, offering, dest, res);

    assertTrue(implementednetwork != null);

    assertTrue(implementednetwork.getCidr().equals("10.1.1.0/24"));

    assertTrue(implementednetwork.getGateway().equals("10.1.1.1"));

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testShutdown() throws InsufficientVirtualNetworkCapacityException, URISyntaxException {

    PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById(anyLong())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "VXLAN" }));

    when(physnet.getId()).thenReturn(42L);

    NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(42L);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    NetworkVO network = mock(NetworkVO.class);

    when(network.getName()).thenReturn("testnetwork");

    when(network.getState()).thenReturn(State.Implementing);

    when(network.getBroadcastDomainType()).thenReturn(BroadcastDomainType.Vxlan);

    when(network.getBroadcastUri()).thenReturn(new URI("vxlan:12345"));

    when(network.getPhysicalNetworkId()).thenReturn(42L);

    when(netdao.findById(42L)).thenReturn(network);

    DeployDestination dest = mock(DeployDestination.class);

    DataCenter dc = mock(DataCenter.class);

    when(dest.getDataCenter()).thenReturn(dc);

    when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(42L);

    Domain dom = mock(Domain.class);

    when(dom.getName()).thenReturn("domain");

    Account acc = mock(Account.class);

    when(acc.getAccountName()).thenReturn("accountname");

    ReservationContext res = mock(ReservationContext.class);

    when(res.getDomain()).thenReturn(dom);

    when(res.getAccount()).thenReturn(acc);

    NetworkProfile implementednetwork = mock(NetworkProfile.class);

    when(implementednetwork.getId()).thenReturn(42L);

    when(implementednetwork.getBroadcastUri()).thenReturn(new URI("vxlan:12345"));

    when(offering.isSpecifyVlan()).thenReturn(false);

    guru.shutdown(implementednetwork, offering);

    verify(implementednetwork, times(1)).setBroadcastUri(null);

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long findPhysicalNetworkIdReturn) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.findPhysicalNetworkId(anyLong(), (String) any(), (TrafficType) any())).thenReturn(findPhysicalNetworkIdReturn);
        return netmodel;
    }
}

@Test

public void testDesign() {

    final PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById((Long) any())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "VCS" }));

    when(physnet.getId()).thenReturn(NETWORK_ID);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    when(nosd.areServicesSupportedByNetworkOffering(NETWORK_ID, Service.Connectivity)).thenReturn(true);

    when(netmodel.listNetworkOfferingServices(NETWORK_ID)).thenReturn(Arrays.asList(Service.Connectivity));

    final DeploymentPlan plan = mock(DeploymentPlan.class);

    final Network network = mock(Network.class);

    final Account account = mock(Account.class);

    final Network designednetwork = guru.design(offering, plan, network, account);

    assertTrue(designednetwork != null);

    assertTrue(designednetwork.getBroadcastDomainType() == BroadcastDomainType.Vcs);

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long networkId, Service... services) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.listNetworkOfferingServices(networkId)).thenReturn(Arrays.asList(services));
        return netmodel;
    }
}

@Test

public void testDesign() {

    final PhysicalNetworkVO physnet = mock(PhysicalNetworkVO.class);

    when(physnetdao.findById((Long) any())).thenReturn(physnet);

    when(physnet.getIsolationMethods()).thenReturn(Arrays.asList(new String[] { "STT", "VXLAN" }));

    when(physnet.getId()).thenReturn(NETWORK_ID);

    final NiciraNvpDeviceVO device = mock(NiciraNvpDeviceVO.class);

    when(nvpdao.listByPhysicalNetwork(NETWORK_ID)).thenReturn(Arrays.asList(new NiciraNvpDeviceVO[] { device }));

    when(device.getId()).thenReturn(1L);

    final NetworkOffering offering = mock(NetworkOffering.class);

    when(offering.getId()).thenReturn(NETWORK_ID);

    when(offering.getTrafficType()).thenReturn(TrafficType.Guest);

    when(offering.getGuestType()).thenReturn(GuestType.Isolated);

    when(nosd.areServicesSupportedByNetworkOffering(NETWORK_ID, Service.Connectivity)).thenReturn(true);

    when(netmodel.listNetworkOfferingServices(NETWORK_ID)).thenReturn(Arrays.asList(Service.Connectivity));

    final DeploymentPlan plan = mock(DeploymentPlan.class);

    final Network network = mock(Network.class);

    final Account account = mock(Account.class);

    final Network designednetwork = guru.design(offering, plan, network, account);

    assertTrue(designednetwork != null);

    assertTrue(designednetwork.getBroadcastDomainType() == BroadcastDomainType.Lswitch);

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(long networkId, Service... services) {
        NetworkModel netmodel = mock(NetworkModel.class);
        when(netmodel.listNetworkOfferingServices(networkId)).thenReturn(Arrays.asList(services));
        return netmodel;
    }
}

@Test

public void executeTest() throws Exception {

    SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);

    DataCenter dataCenter = Mockito.mock(DataCenter.class);

    Network managementNetwork = Mockito.mock(Network.class);

    TransactionCallbackNoReturn transactionCallbackNoReturn = Mockito.mock(TransactionCallbackNoReturn.class);

    List<NetworkOfferingVO> systemNetworkOffering = Arrays.asList(Mockito.mock(NetworkOfferingVO.class));

    mockStatic(Transaction.class);

    Mockito.when(entityManager.findById(ArgumentMatchers.any(), ArgumentMatchers.anyLong())).thenReturn(dataCenter);

    Mockito.when(dataCenter.isSecurityGroupEnabled()).thenReturn(true);

    Mockito.when(networkModel.getSystemNetworkByZoneAndTrafficType(ArgumentMatchers.anyLong(), ArgumentMatchers.any())).thenReturn(managementNetwork);

    Mockito.when(networkOfferingDao.listSystemNetworkOfferings()).thenReturn(systemNetworkOffering);

    PowerMockito.when(Transaction.execute(any(TransactionCallbackNoReturn.class))).thenReturn(transactionCallbackNoReturn);

    PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);

    configTungstenFabricServiceCmd.execute();

    Assert.assertEquals(successResponse, configTungstenFabricServiceCmd.getResponseObject());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network systemNetwork) {
        NetworkModel networkModel = Mockito.mock(NetworkModel.class);
        Mockito.when(networkModel.getSystemNetworkByZoneAndTrafficType(ArgumentMatchers.anyLong(), ArgumentMatchers.any()))
               .thenReturn(systemNetwork);
        return networkModel;
    }
}

@Test

public void executeTest() throws Exception {

    SuccessResponse successResponse = Mockito.mock(SuccessResponse.class);

    Network publicNetwork = Mockito.mock(Network.class);

    SearchCriteria<VlanVO> sc = Mockito.mock(SearchCriteria.class);

    List<VlanVO> pubVlanVOList = Arrays.asList(Mockito.mock(VlanVO.class));

    Mockito.when(networkModel.getSystemNetworkByZoneAndTrafficType(ArgumentMatchers.anyLong(), ArgumentMatchers.any())).thenReturn(publicNetwork);

    Mockito.when(vlanDao.createSearchCriteria()).thenReturn(sc);

    Mockito.when(vlanDao.listVlansByNetworkId(ArgumentMatchers.anyLong())).thenReturn(pubVlanVOList);

    Mockito.when(tungstenService.createPublicNetwork(ArgumentMatchers.anyLong())).thenReturn(true);

    Mockito.when(tungstenService.addPublicNetworkSubnet(ArgumentMatchers.any())).thenReturn(true);

    PowerMockito.whenNew(SuccessResponse.class).withAnyArguments().thenReturn(successResponse);

    createTungstenFabricPublicNetworkCmd.execute();

    Assert.assertEquals(successResponse, createTungstenFabricPublicNetworkCmd.getResponseObject());

}

public class MockNetworkModel {
    public static NetworkModel createMockNetworkModel(Network systemNetwork) {
        NetworkModel networkModel = Mockito.mock(NetworkModel.class);
        Mockito.when(networkModel.getSystemNetworkByZoneAndTrafficType(ArgumentMatchers.anyLong(), ArgumentMatchers.any()))
               .thenReturn(systemNetwork);
        return networkModel;
    }
}

@Test(expected = CloudRuntimeException.class)

public void testUserDataDenyOverride() {

    Long userDataId = 1L;

    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);

    when(template.getUserDataId()).thenReturn(2L);

    when(template.getUserDataOverridePolicy()).thenReturn(UserData.UserDataOverridePolicy.DENYOVERRIDE);

    userVmManagerImpl.finalizeUserData(null, userDataId, template);

}

private static VirtualMachineTemplate createMockVirtualMachineTemplate(UserData.UserDataOverridePolicy overridePolicy) {
    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
    when(template.getUserDataId()).thenReturn(2L);
    when(template.getUserDataOverridePolicy()).thenReturn(overridePolicy);
    return template;
}

@Test

public void testUserDataAllowOverride() {

    String templateUserData = "testTemplateUserdata";

    Long userDataId = 1L;

    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);

    when(template.getUserDataId()).thenReturn(2L);

    when(template.getUserDataOverridePolicy()).thenReturn(UserData.UserDataOverridePolicy.ALLOWOVERRIDE);

    UserDataVO apiUserDataVO = Mockito.mock(UserDataVO.class);

    doReturn(apiUserDataVO).when(userDataDao).findById(userDataId);

    when(apiUserDataVO.getUserData()).thenReturn(templateUserData);

    String finalUserdata = userVmManagerImpl.finalizeUserData(null, userDataId, template);

    Assert.assertEquals(finalUserdata, templateUserData);

}

private static VirtualMachineTemplate createMockVirtualMachineTemplate(UserData.UserDataOverridePolicy overridePolicy) {
    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
    when(template.getUserDataId()).thenReturn(2L);
    when(template.getUserDataOverridePolicy()).thenReturn(overridePolicy);
    return template;
}

@Test

public void testUserDataAppend() {

    String userData = "testUserdata";

    String templateUserData = "testTemplateUserdata";

    Long userDataId = 1L;

    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);

    when(template.getUserDataId()).thenReturn(2L);

    when(template.getUserDataOverridePolicy()).thenReturn(UserData.UserDataOverridePolicy.APPEND);

    UserDataVO templateUserDataVO = Mockito.mock(UserDataVO.class);

    doReturn(templateUserDataVO).when(userDataDao).findById(2L);

    when(templateUserDataVO.getUserData()).thenReturn(templateUserData);

    UserDataVO apiUserDataVO = Mockito.mock(UserDataVO.class);

    doReturn(apiUserDataVO).when(userDataDao).findById(userDataId);

    when(apiUserDataVO.getUserData()).thenReturn(userData);

    String finalUserdata = userVmManagerImpl.finalizeUserData(null, userDataId, template);

    Assert.assertEquals(finalUserdata, templateUserData + userData);

}

private static VirtualMachineTemplate createMockVirtualMachineTemplate(UserData.UserDataOverridePolicy overridePolicy) {
    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
    when(template.getUserDataId()).thenReturn(2L);
    when(template.getUserDataOverridePolicy()).thenReturn(overridePolicy);
    return template;
}

@Test

public void testUserDataAllowOverrideWithoutAPIuserdata() {

    String templateUserData = "testTemplateUserdata";

    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);

    when(template.getUserDataId()).thenReturn(2L);

    when(template.getUserDataOverridePolicy()).thenReturn(UserData.UserDataOverridePolicy.ALLOWOVERRIDE);

    UserDataVO templateUserDataVO = Mockito.mock(UserDataVO.class);

    doReturn(templateUserDataVO).when(userDataDao).findById(2L);

    when(templateUserDataVO.getUserData()).thenReturn(templateUserData);

    String finalUserdata = userVmManagerImpl.finalizeUserData(null, null, template);

    Assert.assertEquals(finalUserdata, templateUserData);

}

private static VirtualMachineTemplate createMockVirtualMachineTemplate(UserData.UserDataOverridePolicy overridePolicy) {
    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
    when(template.getUserDataId()).thenReturn(2L);
    when(template.getUserDataOverridePolicy()).thenReturn(overridePolicy);
    return template;
}

@Test

public void testUserDataWithoutTemplate() {

    String userData = "testUserdata";

    Long userDataId = 1L;

    UserDataVO apiUserDataVO = Mockito.mock(UserDataVO.class);

    doReturn(apiUserDataVO).when(userDataDao).findById(userDataId);

    when(apiUserDataVO.getUserData()).thenReturn(userData);

    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);

    when(template.getUserDataId()).thenReturn(null);

    String finalUserdata = userVmManagerImpl.finalizeUserData(null, userDataId, template);

    Assert.assertEquals(finalUserdata, userData);

}

private static VirtualMachineTemplate createMockVirtualMachineTemplate() {
    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
    when(template.getUserDataId()).thenReturn(null);
    return template;
}

@Test

public void testUserDataAllowOverrideWithUserdataText() {

    String userData = "testUserdata";

    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);

    when(template.getUserDataId()).thenReturn(null);

    String finalUserdata = userVmManagerImpl.finalizeUserData(userData, null, template);

    Assert.assertEquals(finalUserdata, userData);

}

private static VirtualMachineTemplate createMockVirtualMachineTemplate() {
    VirtualMachineTemplate template = Mockito.mock(VirtualMachineTemplate.class);
    when(template.getUserDataId()).thenReturn(null);
    return template;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void moveRuleBetweenAclRulesTestThereIsSpaceBetweenPreviousRuleAndNextRuleToAccomodateTheNewRule() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(11);

    Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    NetworkACLItemVO networkACLItemVO12 = new NetworkACLItemVO();

    networkACLItemVO12.setNumber(12);

    NetworkACLItemVO networkACLItemVO13 = new NetworkACLItemVO();

    networkACLItemVO13.setNumber(13);

    NetworkACLItemVO networkACLItemVO14 = new NetworkACLItemVO();

    networkACLItemVO14.setNumber(14);

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(nextAclRuleMock);

    allAclRules.add(networkACLItemVO12);

    allAclRules.add(networkACLItemVO13);

    allAclRules.add(networkACLItemVO14);

    allAclRules.add(aclRuleBeingMovedMock);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclItemDaoMock).findById(1l);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());

    networkAclServiceImpl.moveRuleBetweenAclRules(aclRuleBeingMovedMock, allAclRules, previousAclRuleMock, nextAclRuleMock);

    Mockito.verify(networkAclItemDaoMock, times(0)).updateNumberFieldNetworkItem(aclRuleBeingMovedMock.getId(), 11);

    Mockito.verify(networkAclItemDaoMock, times(0)).findById(1l);

    Mockito.verify(networkAclServiceImpl, Mockito.times(1)).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.eq(11), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(1));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void updateAclRuleToNewPositionAndExecuteShiftIfNecessaryTest() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(11);

    Mockito.when(nextAclRuleMock.getId()).thenReturn(50l);

    Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    NetworkACLItemVO networkACLItemVO12 = new NetworkACLItemVO();

    networkACLItemVO12.setNumber(12);

    networkACLItemVO12.id = 12;

    NetworkACLItemVO networkACLItemVO13 = new NetworkACLItemVO();

    networkACLItemVO13.id = 13;

    networkACLItemVO13.setNumber(13);

    NetworkACLItemVO networkACLItemVO14 = new NetworkACLItemVO();

    networkACLItemVO14.setNumber(14);

    networkACLItemVO14.id = 14;

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(nextAclRuleMock);

    allAclRules.add(networkACLItemVO12);

    allAclRules.add(networkACLItemVO13);

    allAclRules.add(networkACLItemVO14);

    allAclRules.add(aclRuleBeingMovedMock);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(null).when(networkAclItemDaoMock).findById(Mockito.anyLong());

    networkAclServiceImpl.updateAclRuleToNewPositionAndExecuteShiftIfNecessary(aclRuleBeingMovedMock, 11, allAclRules, 1);

    Mockito.verify(aclRuleBeingMovedMock).setNumber(11);

    Mockito.verify(nextAclRuleMock).setNumber(12);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(1l, 11);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(50l, 12);

    Assert.assertEquals(13, networkACLItemVO12.getNumber());

    Assert.assertEquals(14, networkACLItemVO13.getNumber());

    Assert.assertEquals(15, networkACLItemVO14.getNumber());

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void moveRuleBetweenAclRulesTestThereIsNoSpaceBetweenPreviousRuleAndNextRuleToAccomodateTheNewRule() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(15);

    Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(nextAclRuleMock);

    allAclRules.add(aclRuleBeingMovedMock);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclItemDaoMock).findById(1l);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());

    networkAclServiceImpl.moveRuleBetweenAclRules(aclRuleBeingMovedMock, allAclRules, previousAclRuleMock, nextAclRuleMock);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(aclRuleBeingMovedMock.getId(), 11);

    Mockito.verify(networkAclItemDaoMock).findById(1l);

    Mockito.verify(networkAclServiceImpl, Mockito.times(0)).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void updateAclRuleToNewPositionAndExecuteShiftIfNecessaryTest() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(11);

    Mockito.when(nextAclRuleMock.getId()).thenReturn(50l);

    Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    NetworkACLItemVO networkACLItemVO12 = new NetworkACLItemVO();

    networkACLItemVO12.setNumber(12);

    networkACLItemVO12.id = 12;

    NetworkACLItemVO networkACLItemVO13 = new NetworkACLItemVO();

    networkACLItemVO13.id = 13;

    networkACLItemVO13.setNumber(13);

    NetworkACLItemVO networkACLItemVO14 = new NetworkACLItemVO();

    networkACLItemVO14.setNumber(14);

    networkACLItemVO14.id = 14;

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(nextAclRuleMock);

    allAclRules.add(networkACLItemVO12);

    allAclRules.add(networkACLItemVO13);

    allAclRules.add(networkACLItemVO14);

    allAclRules.add(aclRuleBeingMovedMock);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(null).when(networkAclItemDaoMock).findById(Mockito.anyLong());

    networkAclServiceImpl.updateAclRuleToNewPositionAndExecuteShiftIfNecessary(aclRuleBeingMovedMock, 11, allAclRules, 1);

    Mockito.verify(aclRuleBeingMovedMock).setNumber(11);

    Mockito.verify(nextAclRuleMock).setNumber(12);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(1l, 11);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(50l, 12);

    Assert.assertEquals(13, networkACLItemVO12.getNumber());

    Assert.assertEquals(14, networkACLItemVO13.getNumber());

    Assert.assertEquals(15, networkACLItemVO14.getNumber());

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

@Test(expected = InvalidParameterValueException.class)

public void moveRuleBetweenAclRulesTestThereIsSpaceBetweenPreviousRuleAndNextRuleToAccomodateTheNewRuleWithOtherruleColliding() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(15);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    NetworkACLItemVO networkACLItemVO1 = new NetworkACLItemVO();

    networkACLItemVO1.setNumber(11);

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(networkACLItemVO1);

    allAclRules.add(nextAclRuleMock);

    networkAclServiceImpl.moveRuleBetweenAclRules(aclRuleBeingMovedMock, allAclRules, previousAclRuleMock, nextAclRuleMock);

}
private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void moveRuleBetweenAclRulesTestThereIsSpaceBetweenPreviousRuleAndNextRuleToAccomodateTheNewRule() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(11);

    Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    NetworkACLItemVO networkACLItemVO12 = new NetworkACLItemVO();

    networkACLItemVO12.setNumber(12);

    NetworkACLItemVO networkACLItemVO13 = new NetworkACLItemVO();

    networkACLItemVO13.setNumber(13);

    NetworkACLItemVO networkACLItemVO14 = new NetworkACLItemVO();

    networkACLItemVO14.setNumber(14);

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(nextAclRuleMock);

    allAclRules.add(networkACLItemVO12);

    allAclRules.add(networkACLItemVO13);

    allAclRules.add(networkACLItemVO14);

    allAclRules.add(aclRuleBeingMovedMock);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclItemDaoMock).findById(1l);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());

    networkAclServiceImpl.moveRuleBetweenAclRules(aclRuleBeingMovedMock, allAclRules, previousAclRuleMock, nextAclRuleMock);

    Mockito.verify(networkAclItemDaoMock, times(0)).updateNumberFieldNetworkItem(aclRuleBeingMovedMock.getId(), 11);

    Mockito.verify(networkAclItemDaoMock, times(0)).findById(1l);

    Mockito.verify(networkAclServiceImpl, Mockito.times(1)).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.eq(11), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(1));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void moveRuleBetweenAclRulesTestThereIsNoSpaceBetweenPreviousRuleAndNextRuleToAccomodateTheNewRule() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(15);

    Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(nextAclRuleMock);

    allAclRules.add(aclRuleBeingMovedMock);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclItemDaoMock).findById(1l);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());

    networkAclServiceImpl.moveRuleBetweenAclRules(aclRuleBeingMovedMock, allAclRules, previousAclRuleMock, nextAclRuleMock);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(aclRuleBeingMovedMock.getId(), 11);

    Mockito.verify(networkAclItemDaoMock).findById(1l);

    Mockito.verify(networkAclServiceImpl, Mockito.times(0)).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void updateAclRuleToNewPositionAndExecuteShiftIfNecessaryTest() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(11);

    Mockito.when(nextAclRuleMock.getId()).thenReturn(50l);

    Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    NetworkACLItemVO networkACLItemVO12 = new NetworkACLItemVO();

    networkACLItemVO12.setNumber(12);

    networkACLItemVO12.id = 12;

    NetworkACLItemVO networkACLItemVO13 = new NetworkACLItemVO();

    networkACLItemVO13.id = 13;

    networkACLItemVO13.setNumber(13);

    NetworkACLItemVO networkACLItemVO14 = new NetworkACLItemVO();

    networkACLItemVO14.setNumber(14);

    networkACLItemVO14.id = 14;

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(nextAclRuleMock);

    allAclRules.add(networkACLItemVO12);

    allAclRules.add(networkACLItemVO13);

    allAclRules.add(networkACLItemVO14);

    allAclRules.add(aclRuleBeingMovedMock);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(null).when(networkAclItemDaoMock).findById(Mockito.anyLong());

    networkAclServiceImpl.updateAclRuleToNewPositionAndExecuteShiftIfNecessary(aclRuleBeingMovedMock, 11, allAclRules, 1);

    Mockito.verify(aclRuleBeingMovedMock).setNumber(11);

    Mockito.verify(nextAclRuleMock).setNumber(12);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(1l, 11);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(50l, 12);

    Assert.assertEquals(13, networkACLItemVO12.getNumber());

    Assert.assertEquals(14, networkACLItemVO13.getNumber());

    Assert.assertEquals(15, networkACLItemVO14.getNumber());

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

@Test(expected = InvalidParameterValueException.class)

public void moveRuleBetweenAclRulesTestThereIsSpaceBetweenPreviousRuleAndNextRuleToAccomodateTheNewRuleWithOtherruleColliding() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(15);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    NetworkACLItemVO networkACLItemVO1 = new NetworkACLItemVO();

    networkACLItemVO1.setNumber(11);

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(networkACLItemVO1);

    allAclRules.add(nextAclRuleMock);

    networkAclServiceImpl.moveRuleBetweenAclRules(aclRuleBeingMovedMock, allAclRules, previousAclRuleMock, nextAclRuleMock);

}
private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void moveRuleBetweenAclRulesTestThereIsSpaceBetweenPreviousRuleAndNextRuleToAccomodateTheNewRule() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(11);

    Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    NetworkACLItemVO networkACLItemVO12 = new NetworkACLItemVO();

    networkACLItemVO12.setNumber(12);

    NetworkACLItemVO networkACLItemVO13 = new NetworkACLItemVO();

    networkACLItemVO13.setNumber(13);

    NetworkACLItemVO networkACLItemVO14 = new NetworkACLItemVO();

    networkACLItemVO14.setNumber(14);

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(nextAclRuleMock);

    allAclRules.add(networkACLItemVO12);

    allAclRules.add(networkACLItemVO13);

    allAclRules.add(networkACLItemVO14);

    allAclRules.add(aclRuleBeingMovedMock);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclItemDaoMock).findById(1l);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());

    networkAclServiceImpl.moveRuleBetweenAclRules(aclRuleBeingMovedMock, allAclRules, previousAclRuleMock, nextAclRuleMock);

    Mockito.verify(networkAclItemDaoMock, times(0)).updateNumberFieldNetworkItem(aclRuleBeingMovedMock.getId(), 11);

    Mockito.verify(networkAclItemDaoMock, times(0)).findById(1l);

    Mockito.verify(networkAclServiceImpl, Mockito.times(1)).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.eq(11), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(1));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void moveRuleBetweenAclRulesTestThereIsNoSpaceBetweenPreviousRuleAndNextRuleToAccomodateTheNewRule() {

    Mockito.when(previousAclRuleMock.getNumber()).thenReturn(10);

    Mockito.when(nextAclRuleMock.getNumber()).thenReturn(15);

    Mockito.when(aclRuleBeingMovedMock.getNumber()).thenReturn(50);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(1l);

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    allAclRules.add(previousAclRuleMock);

    allAclRules.add(nextAclRuleMock);

    allAclRules.add(aclRuleBeingMovedMock);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclItemDaoMock).findById(1l);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());

    networkAclServiceImpl.moveRuleBetweenAclRules(aclRuleBeingMovedMock, allAclRules, previousAclRuleMock, nextAclRuleMock);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(aclRuleBeingMovedMock.getId(), 11);

    Mockito.verify(networkAclItemDaoMock).findById(1l);

    Mockito.verify(networkAclServiceImpl, Mockito.times(0)).updateAclRuleToNewPositionAndExecuteShiftIfNecessary(Mockito.any(NetworkACLItemVO.class), Mockito.anyInt(), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.anyInt());

}

private static NetworkACLItemVO createMockNetworkACLItemVO(int numberReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getNumber()).thenReturn(numberReturn);
    return mock;
}

@Test(expected = InvalidParameterValueException.class)

public void transferDataToNetworkAclRulePojoTestNumberOfAcltoBeUpdatedAlreadyInUse() {

    int aclNumberToUpdate = 1;

    Mockito.when(updateNetworkACLItemCmdMock.getNumber()).thenReturn(aclNumberToUpdate);

    Mockito.when(networkAclMock.getId()).thenReturn(networkAclMockId);

    Mockito.when(networkAclItemVoMock.getId()).thenReturn(100L);

    NetworkACLItemVO otherNetworkAclItemVoMock = Mockito.mock(NetworkACLItemVO.class);

    Mockito.when(otherNetworkAclItemVoMock.getId()).thenReturn(101L);

    Mockito.doReturn(otherNetworkAclItemVoMock).when(networkAclItemDaoMock).findByAclAndNumber(networkAclMockId, aclNumberToUpdate);

    networkAclServiceImpl.transferDataToNetworkAclRulePojo(updateNetworkACLItemCmdMock, networkAclItemVoMock, networkAclMock);

}

private static NetworkACLItemVO createMockNetworkAclItemVo(long id) {
    NetworkACLItemVO networkAclItemVoMock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(networkAclItemVoMock.getId()).thenReturn(id);
    return networkAclItemVoMock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test

public void moveRuleToTheBottomTest() {

    ArrayList<NetworkACLItemVO> allAclRules = new ArrayList<>();

    NetworkACLItemVO networkACLItemVO1 = new NetworkACLItemVO();

    networkACLItemVO1.setNumber(100);

    allAclRules.add(networkACLItemVO1);

    Mockito.when(aclRuleBeingMovedMock.getId()).thenReturn(99l);

    Mockito.doNothing().when(networkAclItemDaoMock).updateNumberFieldNetworkItem(Mockito.anyLong(), Mockito.anyInt());

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclItemDaoMock).findById(99l);

    networkAclServiceImpl.moveRuleToTheBottom(aclRuleBeingMovedMock, allAclRules);

    Mockito.verify(aclRuleBeingMovedMock).setNumber(101);

    Mockito.verify(networkAclItemDaoMock).updateNumberFieldNetworkItem(99l, 101);

    Mockito.verify(networkAclItemDaoMock).findById(99l);

}

private static NetworkACLItemVO createMockNetworkAclItemVo(long id) {
    NetworkACLItemVO networkAclItemVoMock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(networkAclItemVoMock.getId()).thenReturn(id);
    return networkAclItemVoMock;
}

@Test

public void validateMoveAclRulesDataTestSuccesfullExecution() {

    Mockito.when(nextAclRuleMock.getAclId()).thenReturn(networkAclMockId);

    Mockito.when(previousAclRuleMock.getAclId()).thenReturn(networkAclMockId);

    Mockito.doReturn(networkAclMock).when(networkAclDaoMock).findById(networkAclMockId);

    Mockito.doReturn(Mockito.mock(Vpc.class)).when(entityManagerMock).findById(Vpc.class, networkMockVpcMockId);

    CallContext callContextMock = Mockito.mock(CallContext.class);

    Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();

    PowerMockito.mockStatic(CallContext.class);

    PowerMockito.when(CallContext.current()).thenReturn(callContextMock);

    Mockito.doNothing().when(accountManagerMock).checkAccess(Mockito.any(Account.class), Mockito.isNull(AccessType.class), Mockito.eq(true), Mockito.any(Vpc.class));

    networkAclServiceImpl.validateMoveAclRulesData(aclRuleBeingMovedMock, previousAclRuleMock, nextAclRuleMock);

    Mockito.verify(networkAclDaoMock).findById(networkAclMockId);

    Mockito.verify(entityManagerMock).findById(Vpc.class, networkMockVpcMockId);

    Mockito.verify(accountManagerMock).checkAccess(Mockito.any(Account.class), Mockito.isNull(AccessType.class), Mockito.eq(true), Mockito.any(Vpc.class));

}
private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(Long aclId) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getAclId()).thenReturn(aclId);
    return mock;
}

@Test

public void updateNetworkACLItemTest() throws ResourceUnavailableException {

    Mockito.when(networkAclItemVoMock.getAclId()).thenReturn(networkAclMockId);

    Mockito.doReturn(networkAclItemVoMock).when(networkAclServiceImpl).validateNetworkAclRuleIdAndRetrieveIt(updateNetworkACLItemCmdMock);

    Mockito.doReturn(networkAclMock).when(networkAclManagerMock).getNetworkACL(networkAclMockId);

    Mockito.doNothing().when(networkAclServiceImpl).validateNetworkAcl(Mockito.eq(networkAclMock));

    Mockito.doNothing().when(networkAclServiceImpl).transferDataToNetworkAclRulePojo(Mockito.eq(updateNetworkACLItemCmdMock), Mockito.eq(networkAclItemVoMock), Mockito.eq(networkAclMock));

    Mockito.doNothing().when(networkAclServiceImpl).validateNetworkACLItem(networkAclItemVoMock);

    Mockito.doReturn(networkAclItemVoMock).when(networkAclManagerMock).updateNetworkACLItem(networkAclItemVoMock);

    networkAclServiceImpl.updateNetworkACLItem(updateNetworkACLItemCmdMock);

    InOrder inOrder = Mockito.inOrder(networkAclServiceImpl, networkAclManagerMock);

    inOrder.verify(networkAclServiceImpl).validateNetworkAclRuleIdAndRetrieveIt(updateNetworkACLItemCmdMock);

    inOrder.verify(networkAclManagerMock).getNetworkACL(networkAclMockId);

    inOrder.verify(networkAclServiceImpl).validateNetworkAcl(networkAclMock);

    inOrder.verify(networkAclServiceImpl).transferDataToNetworkAclRulePojo(Mockito.eq(updateNetworkACLItemCmdMock), Mockito.eq(networkAclItemVoMock), Mockito.eq(networkAclMock));

    inOrder.verify(networkAclServiceImpl).validateNetworkACLItem(networkAclItemVoMock);

    inOrder.verify(networkAclManagerMock).updateNetworkACLItem(networkAclItemVoMock);

}

private static NetworkACLItemVO createMockNetworkACLItemVO(Long aclId) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getAclId()).thenReturn(aclId);
    return mock;
}

@Test

public void validateMoveAclRulesDataTestSuccesfullExecution() {

    Mockito.when(nextAclRuleMock.getAclId()).thenReturn(networkAclMockId);

    Mockito.when(previousAclRuleMock.getAclId()).thenReturn(networkAclMockId);

    Mockito.doReturn(networkAclMock).when(networkAclDaoMock).findById(networkAclMockId);

    Mockito.doReturn(Mockito.mock(Vpc.class)).when(entityManagerMock).findById(Vpc.class, networkMockVpcMockId);

    CallContext callContextMock = Mockito.mock(CallContext.class);

    Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();

    PowerMockito.mockStatic(CallContext.class);

    PowerMockito.when(CallContext.current()).thenReturn(callContextMock);

    Mockito.doNothing().when(accountManagerMock).checkAccess(Mockito.any(Account.class), Mockito.isNull(AccessType.class), Mockito.eq(true), Mockito.any(Vpc.class));

    networkAclServiceImpl.validateMoveAclRulesData(aclRuleBeingMovedMock, previousAclRuleMock, nextAclRuleMock);

    Mockito.verify(networkAclDaoMock).findById(networkAclMockId);

    Mockito.verify(entityManagerMock).findById(Vpc.class, networkMockVpcMockId);

    Mockito.verify(accountManagerMock).checkAccess(Mockito.any(Account.class), Mockito.isNull(AccessType.class), Mockito.eq(true), Mockito.any(Vpc.class));

}
private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(Long aclId) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getAclId()).thenReturn(aclId);
    return mock;
}

@Before

public void befoteTest() {

    PowerMockito.mockStatic(CallContext.class);

    PowerMockito.when(CallContext.current()).thenReturn(callContextMock);

    Mockito.doReturn(Mockito.mock(User.class)).when(callContextMock).getCallingUser();

    Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();

    Mockito.when(networkAclDaoMock.findById(networkAclListId)).thenReturn(networkACLVOMock);

    Mockito.when(createNetworkAclCmdMock.getNetworkId()).thenReturn(1L);

    Mockito.when(createNetworkAclCmdMock.getProtocol()).thenReturn("tcp");

    Mockito.when(networkMock.getNetworkOfferingId()).thenReturn(networkOfferingMockId);

    Mockito.when(networkMock.getVpcId()).thenReturn(networkMockVpcMockId);

    Mockito.when(moveNetworkAclItemCmdMock.getUuidRuleBeingMoved()).thenReturn(uuidAclRuleBeingMoved);

    Mockito.when(aclRuleBeingMovedMock.getUuid()).thenReturn(uuidAclRuleBeingMoved);

    Mockito.when(aclRuleBeingMovedMock.getAclId()).thenReturn(networkAclMockId);

    Mockito.when(previousAclRuleMock.getUuid()).thenReturn(previousAclRuleUuid);

    Mockito.when(nextAclRuleMock.getUuid()).thenReturn(nextAclRuleUuid);

    Mockito.when(networkAclMock.getVpcId()).thenReturn(networkMockVpcMockId);

}
private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(Long aclId) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getAclId()).thenReturn(aclId);
    return mock;
}

@Before

public void befoteTest() {

    PowerMockito.mockStatic(CallContext.class);

    PowerMockito.when(CallContext.current()).thenReturn(callContextMock);

    Mockito.doReturn(Mockito.mock(User.class)).when(callContextMock).getCallingUser();

    Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();

    Mockito.when(networkAclDaoMock.findById(networkAclListId)).thenReturn(networkACLVOMock);

    Mockito.when(createNetworkAclCmdMock.getNetworkId()).thenReturn(1L);

    Mockito.when(createNetworkAclCmdMock.getProtocol()).thenReturn("tcp");

    Mockito.when(networkMock.getNetworkOfferingId()).thenReturn(networkOfferingMockId);

    Mockito.when(networkMock.getVpcId()).thenReturn(networkMockVpcMockId);

    Mockito.when(moveNetworkAclItemCmdMock.getUuidRuleBeingMoved()).thenReturn(uuidAclRuleBeingMoved);

    Mockito.when(aclRuleBeingMovedMock.getUuid()).thenReturn(uuidAclRuleBeingMoved);

    Mockito.when(aclRuleBeingMovedMock.getAclId()).thenReturn(networkAclMockId);

    Mockito.when(previousAclRuleMock.getUuid()).thenReturn(previousAclRuleUuid);

    Mockito.when(nextAclRuleMock.getUuid()).thenReturn(nextAclRuleUuid);

    Mockito.when(networkAclMock.getVpcId()).thenReturn(networkMockVpcMockId);

}
private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(String uuidReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getUuid()).thenReturn(uuidReturn);
    return mock;
}

@Before

public void befoteTest() {

    PowerMockito.mockStatic(CallContext.class);

    PowerMockito.when(CallContext.current()).thenReturn(callContextMock);

    Mockito.doReturn(Mockito.mock(User.class)).when(callContextMock).getCallingUser();

    Mockito.doReturn(Mockito.mock(Account.class)).when(callContextMock).getCallingAccount();

    Mockito.when(networkAclDaoMock.findById(networkAclListId)).thenReturn(networkACLVOMock);

    Mockito.when(createNetworkAclCmdMock.getNetworkId()).thenReturn(1L);

    Mockito.when(createNetworkAclCmdMock.getProtocol()).thenReturn("tcp");

    Mockito.when(networkMock.getNetworkOfferingId()).thenReturn(networkOfferingMockId);

    Mockito.when(networkMock.getVpcId()).thenReturn(networkMockVpcMockId);

    Mockito.when(moveNetworkAclItemCmdMock.getUuidRuleBeingMoved()).thenReturn(uuidAclRuleBeingMoved);

    Mockito.when(aclRuleBeingMovedMock.getUuid()).thenReturn(uuidAclRuleBeingMoved);

    Mockito.when(aclRuleBeingMovedMock.getAclId()).thenReturn(networkAclMockId);

    Mockito.when(previousAclRuleMock.getUuid()).thenReturn(previousAclRuleUuid);

    Mockito.when(nextAclRuleMock.getUuid()).thenReturn(nextAclRuleUuid);

    Mockito.when(networkAclMock.getVpcId()).thenReturn(networkMockVpcMockId);

}
private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}

private static NetworkACLItemVO createMockNetworkACLItemVO(String uuidReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getUuid()).thenReturn(uuidReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test(expected = InvalidParameterValueException.class)

public void validateMoveAclRulesDataTestPreviousRuleWithDifferentAclId() {

    Mockito.when(previousAclRuleMock.getAclId()).thenReturn(99L);

    networkAclServiceImpl.validateMoveAclRulesData(aclRuleBeingMovedMock, previousAclRuleMock, null);

}

private static NetworkACLItemVO createMockNetworkACLItemVO(long aclIdReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getAclId()).thenReturn(aclIdReturn);
    return mock;
}

private void configureMoveMethodsToDoNothing() {

    Mockito.doReturn(networkACLVOMock).when(networkAclDaoMock).acquireInLockTable(Mockito.anyLong());

    Mockito.doReturn(true).when(networkAclDaoMock).releaseFromLockTable(Mockito.anyLong());

    Mockito.doNothing().when(networkAclServiceImpl).validateAclConsistency(Mockito.any(MoveNetworkAclItemCmd.class), Mockito.any(NetworkACLVO.class), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(new ArrayList<>()).when(networkAclServiceImpl).getAllAclRulesSortedByNumber(networkAclMockId);

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheTop(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleToTheBottom(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class));

    Mockito.doReturn(aclRuleBeingMovedMock).when(networkAclServiceImpl).moveRuleBetweenAclRules(Mockito.eq(aclRuleBeingMovedMock), Mockito.anyListOf(NetworkACLItemVO.class), Mockito.eq(previousAclRuleMock), Mockito.eq(nextAclRuleMock));

}
@Test(expected = InvalidParameterValueException.class)

public void validateMoveAclRulesDataTestNextRuleWithDifferentAclId() {

    Mockito.when(nextAclRuleMock.getAclId()).thenReturn(99L);

    networkAclServiceImpl.validateMoveAclRulesData(aclRuleBeingMovedMock, null, nextAclRuleMock);

}

private static NetworkACLItemVO createMockNetworkACLItemVO(long aclIdReturn) {
    NetworkACLItemVO mock = Mockito.mock(NetworkACLItemVO.class);
    Mockito.when(mock.getAclId()).thenReturn(aclIdReturn);
    return mock;
}

// active snapshots

@SuppressWarnings("unchecked")

@Test(expected = InvalidParameterValueException.class)

public void testAllocSnapshotF2() throws ResourceAllocationException {

    when(_vmDao.findById(anyLong())).thenReturn(vmMock);

    when(vmMock.getId()).thenReturn(TEST_VM_ID);

    when(vmMock.getState()).thenReturn(State.Stopped);

    when(vmMock.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

    when(volumeInfoMock.getInstanceId()).thenReturn(TEST_VM_ID);

    List<SnapshotVO> mockList = mock(List.class);

    when(mockList.size()).thenReturn(1);

    when(_snapshotDao.listByInstanceId(TEST_VM_ID, Snapshot.State.Creating, Snapshot.State.CreatedOnPrimary, Snapshot.State.BackingUp)).thenReturn(mockList);

    _snapshotMgr.allocSnapshot(TEST_VOLUME_ID, Snapshot.MANUAL_POLICY_ID, null, null);

}

private static List<SnapshotVO> createMockSnapshotVOList(int sizeReturn) {
    List<SnapshotVO> mockList = mock(List.class);
    when(mockList.size()).thenReturn(sizeReturn);
    return mockList;
}

// active vm snapshots

@SuppressWarnings("unchecked")

@Test(expected = CloudRuntimeException.class)

public void testAllocSnapshotF3() throws ResourceAllocationException {

    when(_vmDao.findById(anyLong())).thenReturn(vmMock);

    when(vmMock.getId()).thenReturn(TEST_VM_ID);

    when(vmMock.getState()).thenReturn(State.Stopped);

    when(vmMock.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

    when(volumeInfoMock.getInstanceId()).thenReturn(TEST_VM_ID);

    List<SnapshotVO> mockList = mock(List.class);

    when(mockList.size()).thenReturn(0);

    when(_snapshotDao.listByInstanceId(TEST_VM_ID, Snapshot.State.Creating, Snapshot.State.CreatedOnPrimary, Snapshot.State.BackingUp)).thenReturn(mockList);

    List<VMSnapshotVO> mockList2 = mock(List.class);

    when(mockList2.size()).thenReturn(1);

    when(_vmSnapshotDao.listByInstanceId(TEST_VM_ID, VMSnapshot.State.Creating, VMSnapshot.State.Reverting, VMSnapshot.State.Expunging)).thenReturn(mockList2);

    _snapshotMgr.allocSnapshot(TEST_VOLUME_ID, Snapshot.MANUAL_POLICY_ID, null, null);

}

private static List<SnapshotVO> createMockSnapshotVOList(int sizeReturn) {
    List<SnapshotVO> mockList = mock(List.class);
    when(mockList.size()).thenReturn(sizeReturn);
    return mockList;
}

// successful test

@SuppressWarnings("unchecked")

@Test

public void testAllocSnapshotF4() throws ResourceAllocationException {

    when(_vmDao.findById(anyLong())).thenReturn(vmMock);

    when(vmMock.getId()).thenReturn(TEST_VM_ID);

    when(vmMock.getState()).thenReturn(State.Stopped);

    when(vmMock.getHypervisorType()).thenReturn(Hypervisor.HypervisorType.KVM);

    when(volumeInfoMock.getInstanceId()).thenReturn(TEST_VM_ID);

    List<SnapshotVO> mockList = mock(List.class);

    when(mockList.size()).thenReturn(0);

    when(_snapshotDao.listByInstanceId(TEST_VM_ID, Snapshot.State.Creating, Snapshot.State.CreatedOnPrimary, Snapshot.State.BackingUp)).thenReturn(mockList);

    List<VMSnapshotVO> mockList2 = mock(List.class);

    when(mockList2.size()).thenReturn(0);

    when(_vmSnapshotDao.listByInstanceId(TEST_VM_ID, VMSnapshot.State.Creating, VMSnapshot.State.Reverting, VMSnapshot.State.Expunging)).thenReturn(mockList2);

    when(_snapshotDao.persist(any(SnapshotVO.class))).thenReturn(snapshotMock);

    _snapshotMgr.allocSnapshot(TEST_VOLUME_ID, Snapshot.MANUAL_POLICY_ID, null, null);

}

private static List<SnapshotVO> createMockSnapshotVOList(int sizeReturn) {
    List<SnapshotVO> mockList = mock(List.class);
    when(mockList.size()).thenReturn(sizeReturn);
    return mockList;
}

@Test

public void testProcessWithEmptyPlan() {

    VirtualMachine vm = Mockito.mock(VirtualMachine.class);

    when(vm.getId()).thenReturn(vmId);

    VirtualMachineProfile vmProfile = Mockito.mock(VirtualMachineProfile.class);

    when(vmProfile.getVirtualMachine()).thenReturn(vm);

    List<AffinityGroupVMMapVO> vmGroupMappings = new ArrayList<>();

    vmGroupMappings.add(new AffinityGroupVMMapVO(affinityGroupId, vmId));

    when(_affinityGroupVMMapDao.findByVmIdType(eq(vmId), nullable(String.class))).thenReturn(vmGroupMappings);

    DataCenterDeployment plan = new DataCenterDeployment(zoneId);

    ExcludeList avoid = new ExcludeList();

    AffinityGroupVO affinityGroupVO = Mockito.mock(AffinityGroupVO.class);

    when(affinityGroupDao.findById(affinityGroupId)).thenReturn(affinityGroupVO);

    when(affinityGroupVO.getId()).thenReturn(affinityGroupId);

    List<Long> groupVMIds = new ArrayList<>(Arrays.asList(vmId, vm2Id));

    when(_affinityGroupVMMapDao.listVmIdsByAffinityGroup(affinityGroupId)).thenReturn(groupVMIds);

    VMInstanceVO vm2 = new VMInstanceVO();

    when(vmInstanceDao.findById(vm2Id)).thenReturn(vm2);

    vm2.setHostId(host2Id);

    processor.process(vmProfile, plan, avoid);

    Assert.assertEquals(1, plan.getHostPriorities().size());

    Assert.assertNotNull(plan.getHostPriorities().get(host2Id));

    Assert.assertEquals(Integer.valueOf(1), plan.getHostPriorities().get(host2Id));

}

public class MockVMInstanceDao {
    /**
     * Creates a mock VMInstanceDao with configurable stubbing for findById.
     *
     * @param idToVmMap a map from VM id to VMInstanceVO to be returned by findById
     * @return a mock VMInstanceDao with stubbing applied
     */
    public static VMInstanceDao createMockVMInstanceDao(Map<Long, VMInstanceVO> idToVmMap) {
        VMInstanceDao vmInstanceDao = Mockito.mock(VMInstanceDao.class);
        for (Map.Entry<Long, VMInstanceVO> entry : idToVmMap.entrySet()) {
            when(vmInstanceDao.findById(entry.getKey())).thenReturn(entry.getValue());
        }
        return vmInstanceDao;
    }
}

@Test

public void testProcessWithPlan() {

    VirtualMachine vm = Mockito.mock(VirtualMachine.class);

    when(vm.getId()).thenReturn(vmId);

    VirtualMachineProfile vmProfile = Mockito.mock(VirtualMachineProfile.class);

    when(vmProfile.getVirtualMachine()).thenReturn(vm);

    List<AffinityGroupVMMapVO> vmGroupMappings = new ArrayList<>();

    vmGroupMappings.add(new AffinityGroupVMMapVO(affinityGroupId, vmId));

    when(_affinityGroupVMMapDao.findByVmIdType(eq(vmId), nullable(String.class))).thenReturn(vmGroupMappings);

    DataCenterDeployment plan = new DataCenterDeployment(zoneId);

    plan.adjustHostPriority(host2Id, DeploymentPlan.HostPriorityAdjustment.DEFAULT);

    plan.adjustHostPriority(host3Id, DeploymentPlan.HostPriorityAdjustment.LOWER);

    ExcludeList avoid = new ExcludeList();

    AffinityGroupVO affinityGroupVO = Mockito.mock(AffinityGroupVO.class);

    when(affinityGroupDao.findById(affinityGroupId)).thenReturn(affinityGroupVO);

    when(affinityGroupVO.getId()).thenReturn(affinityGroupId);

    List<Long> groupVMIds = new ArrayList<>(Arrays.asList(vmId, vm2Id, vm3Id));

    when(_affinityGroupVMMapDao.listVmIdsByAffinityGroup(affinityGroupId)).thenReturn(groupVMIds);

    VMInstanceVO vm2 = new VMInstanceVO();

    when(vmInstanceDao.findById(vm2Id)).thenReturn(vm2);

    vm2.setHostId(host2Id);

    VMInstanceVO vm3 = new VMInstanceVO();

    when(vmInstanceDao.findById(vm3Id)).thenReturn(vm3);

    vm3.setHostId(host3Id);

    processor.process(vmProfile, plan, avoid);

    Assert.assertEquals(2, plan.getHostPriorities().size());

    Assert.assertNotNull(plan.getHostPriorities().get(host2Id));

    Assert.assertEquals(Integer.valueOf(1), plan.getHostPriorities().get(host2Id));

    Assert.assertNotNull(plan.getHostPriorities().get(host3Id));

    Assert.assertEquals(Integer.valueOf(0), plan.getHostPriorities().get(host3Id));

}

public class MockVMInstanceDao {
    /**
     * Creates a mock VMInstanceDao with configurable stubbing for findById.
     *
     * @param idToVmMap a map from VM id to VMInstanceVO to be returned by findById
     * @return a mock VMInstanceDao with stubbing applied
     */
    public static VMInstanceDao createMockVMInstanceDao(Map<Long, VMInstanceVO> idToVmMap) {
        VMInstanceDao vmInstanceDao = Mockito.mock(VMInstanceDao.class);
        for (Map.Entry<Long, VMInstanceVO> entry : idToVmMap.entrySet()) {
            when(vmInstanceDao.findById(entry.getKey())).thenReturn(entry.getValue());
        }
        return vmInstanceDao;
    }
}

@Test

public void testProcessWithNotRunningVM() {

    VirtualMachine vm = Mockito.mock(VirtualMachine.class);

    when(vm.getId()).thenReturn(vmId);

    VirtualMachineProfile vmProfile = Mockito.mock(VirtualMachineProfile.class);

    when(vmProfile.getVirtualMachine()).thenReturn(vm);

    List<AffinityGroupVMMapVO> vmGroupMappings = new ArrayList<>();

    vmGroupMappings.add(new AffinityGroupVMMapVO(affinityGroupId, vmId));

    when(_affinityGroupVMMapDao.findByVmIdType(eq(vmId), nullable(String.class))).thenReturn(vmGroupMappings);

    DataCenterDeployment plan = new DataCenterDeployment(zoneId);

    ExcludeList avoid = new ExcludeList();

    AffinityGroupVO affinityGroupVO = Mockito.mock(AffinityGroupVO.class);

    when(affinityGroupDao.findById(affinityGroupId)).thenReturn(affinityGroupVO);

    when(affinityGroupVO.getId()).thenReturn(affinityGroupId);

    List<Long> groupVMIds = new ArrayList<>(Arrays.asList(vmId, vm2Id));

    when(_affinityGroupVMMapDao.listVmIdsByAffinityGroup(affinityGroupId)).thenReturn(groupVMIds);

    VMInstanceVO vm2 = Mockito.mock(VMInstanceVO.class);

    when(vmInstanceDao.findById(vm2Id)).thenReturn(vm2);

    when(vm2.getHostId()).thenReturn(null);

    when(vm2.getLastHostId()).thenReturn(host2Id);

    when(vm2.getState()).thenReturn(VirtualMachine.State.Starting);

    when(vm2.getUpdateTime()).thenReturn(new Date());

    ReflectionTestUtils.setField(processor, "vmCapacityReleaseInterval", 3600);

    processor.process(vmProfile, plan, avoid);

    Assert.assertEquals(1, plan.getHostPriorities().size());

    Assert.assertNotNull(plan.getHostPriorities().get(host2Id));

    Assert.assertEquals(Integer.valueOf(1), plan.getHostPriorities().get(host2Id));

}

public class MockVMInstanceDao {
    /**
     * Creates a mock VMInstanceDao with configurable stubbing for findById.
     *
     * @param idToVmMap a map from VM id to VMInstanceVO to be returned by findById
     * @return a mock VMInstanceDao with stubbing applied
     */
    public static VMInstanceDao createMockVMInstanceDao(Map<Long, VMInstanceVO> idToVmMap) {
        VMInstanceDao vmInstanceDao = Mockito.mock(VMInstanceDao.class);
        for (Map.Entry<Long, VMInstanceVO> entry : idToVmMap.entrySet()) {
            when(vmInstanceDao.findById(entry.getKey())).thenReturn(entry.getValue());
        }
        return vmInstanceDao;
    }
}

@Test

public void testProcessWithEmptyPlan() {

    VirtualMachine vm = Mockito.mock(VirtualMachine.class);

    when(vm.getId()).thenReturn(vmId);

    VirtualMachineProfile vmProfile = Mockito.mock(VirtualMachineProfile.class);

    when(vmProfile.getVirtualMachine()).thenReturn(vm);

    List<AffinityGroupVMMapVO> vmGroupMappings = new ArrayList<>();

    vmGroupMappings.add(new AffinityGroupVMMapVO(affinityGroupId, vmId));

    when(_affinityGroupVMMapDao.findByVmIdType(eq(vmId), nullable(String.class))).thenReturn(vmGroupMappings);

    DataCenterDeployment plan = new DataCenterDeployment(zoneId);

    ExcludeList avoid = new ExcludeList();

    AffinityGroupVO affinityGroupVO = Mockito.mock(AffinityGroupVO.class);

    when(affinityGroupDao.findById(affinityGroupId)).thenReturn(affinityGroupVO);

    when(affinityGroupVO.getId()).thenReturn(affinityGroupId);

    List<Long> groupVMIds = new ArrayList<>(Arrays.asList(vmId, vm2Id));

    when(_affinityGroupVMMapDao.listVmIdsByAffinityGroup(affinityGroupId)).thenReturn(groupVMIds);

    VMInstanceVO vm2 = new VMInstanceVO();

    when(vmInstanceDao.findById(vm2Id)).thenReturn(vm2);

    vm2.setHostId(host2Id);

    processor.process(vmProfile, plan, avoid);

    Assert.assertEquals(1, plan.getHostPriorities().size());

    Assert.assertNotNull(plan.getHostPriorities().get(host2Id));

    Assert.assertEquals(Integer.valueOf(-1), plan.getHostPriorities().get(host2Id));

}

public class MockVMInstanceDao {
    /**
     * Creates a mock VMInstanceDao with configurable stubbing for findById.
     *
     * @param idToVmMap a map from VM id to VMInstanceVO to be returned by findById
     * @return a mock VMInstanceDao with stubbing applied
     */
    public static VMInstanceDao createMockVMInstanceDao(Map<Long, VMInstanceVO> idToVmMap) {
        VMInstanceDao vmInstanceDao = Mockito.mock(VMInstanceDao.class);
        for (Map.Entry<Long, VMInstanceVO> entry : idToVmMap.entrySet()) {
            when(vmInstanceDao.findById(entry.getKey())).thenReturn(entry.getValue());
        }
        return vmInstanceDao;
    }
}

@Test

public void testProcessWithPlan() {

    VirtualMachine vm = Mockito.mock(VirtualMachine.class);

    when(vm.getId()).thenReturn(vmId);

    VirtualMachineProfile vmProfile = Mockito.mock(VirtualMachineProfile.class);

    when(vmProfile.getVirtualMachine()).thenReturn(vm);

    List<AffinityGroupVMMapVO> vmGroupMappings = new ArrayList<>();

    vmGroupMappings.add(new AffinityGroupVMMapVO(affinityGroupId, vmId));

    when(_affinityGroupVMMapDao.findByVmIdType(eq(vmId), nullable(String.class))).thenReturn(vmGroupMappings);

    DataCenterDeployment plan = new DataCenterDeployment(zoneId);

    plan.adjustHostPriority(host2Id, DeploymentPlan.HostPriorityAdjustment.DEFAULT);

    plan.adjustHostPriority(host3Id, DeploymentPlan.HostPriorityAdjustment.HIGHER);

    ExcludeList avoid = new ExcludeList();

    AffinityGroupVO affinityGroupVO = Mockito.mock(AffinityGroupVO.class);

    when(affinityGroupDao.findById(affinityGroupId)).thenReturn(affinityGroupVO);

    when(affinityGroupVO.getId()).thenReturn(affinityGroupId);

    List<Long> groupVMIds = new ArrayList<>(Arrays.asList(vmId, vm2Id, vm3Id));

    when(_affinityGroupVMMapDao.listVmIdsByAffinityGroup(affinityGroupId)).thenReturn(groupVMIds);

    VMInstanceVO vm2 = new VMInstanceVO();

    when(vmInstanceDao.findById(vm2Id)).thenReturn(vm2);

    vm2.setHostId(host2Id);

    VMInstanceVO vm3 = new VMInstanceVO();

    when(vmInstanceDao.findById(vm3Id)).thenReturn(vm3);

    vm3.setHostId(host3Id);

    processor.process(vmProfile, plan, avoid);

    Assert.assertEquals(2, plan.getHostPriorities().size());

    Assert.assertNotNull(plan.getHostPriorities().get(host2Id));

    Assert.assertEquals(Integer.valueOf(-1), plan.getHostPriorities().get(host2Id));

    Assert.assertNotNull(plan.getHostPriorities().get(host3Id));

    Assert.assertEquals(Integer.valueOf(0), plan.getHostPriorities().get(host3Id));

}

public class MockVMInstanceDao {
    /**
     * Creates a mock VMInstanceDao with configurable stubbing for findById.
     *
     * @param idToVmMap a map from VM id to VMInstanceVO to be returned by findById
     * @return a mock VMInstanceDao with stubbing applied
     */
    public static VMInstanceDao createMockVMInstanceDao(Map<Long, VMInstanceVO> idToVmMap) {
        VMInstanceDao vmInstanceDao = Mockito.mock(VMInstanceDao.class);
        for (Map.Entry<Long, VMInstanceVO> entry : idToVmMap.entrySet()) {
            when(vmInstanceDao.findById(entry.getKey())).thenReturn(entry.getValue());
        }
        return vmInstanceDao;
    }
}

@Test

public void testProcessWithNotRunningVM() {

    VirtualMachine vm = Mockito.mock(VirtualMachine.class);

    when(vm.getId()).thenReturn(vmId);

    VirtualMachineProfile vmProfile = Mockito.mock(VirtualMachineProfile.class);

    when(vmProfile.getVirtualMachine()).thenReturn(vm);

    List<AffinityGroupVMMapVO> vmGroupMappings = new ArrayList<>();

    vmGroupMappings.add(new AffinityGroupVMMapVO(affinityGroupId, vmId));

    when(_affinityGroupVMMapDao.findByVmIdType(eq(vmId), nullable(String.class))).thenReturn(vmGroupMappings);

    DataCenterDeployment plan = new DataCenterDeployment(zoneId);

    ExcludeList avoid = new ExcludeList();

    AffinityGroupVO affinityGroupVO = Mockito.mock(AffinityGroupVO.class);

    when(affinityGroupDao.findById(affinityGroupId)).thenReturn(affinityGroupVO);

    when(affinityGroupVO.getId()).thenReturn(affinityGroupId);

    List<Long> groupVMIds = new ArrayList<>(Arrays.asList(vmId, vm2Id));

    when(_affinityGroupVMMapDao.listVmIdsByAffinityGroup(affinityGroupId)).thenReturn(groupVMIds);

    VMInstanceVO vm2 = Mockito.mock(VMInstanceVO.class);

    when(vmInstanceDao.findById(vm2Id)).thenReturn(vm2);

    when(vm2.getHostId()).thenReturn(null);

    when(vm2.getLastHostId()).thenReturn(host2Id);

    when(vm2.getState()).thenReturn(VirtualMachine.State.Starting);

    when(vm2.getUpdateTime()).thenReturn(new Date());

    ReflectionTestUtils.setField(processor, "vmCapacityReleaseInterval", 3600);

    processor.process(vmProfile, plan, avoid);

    Assert.assertEquals(1, plan.getHostPriorities().size());

    Assert.assertNotNull(plan.getHostPriorities().get(host2Id));

    Assert.assertEquals(Integer.valueOf(-1), plan.getHostPriorities().get(host2Id));

}

public class MockVMInstanceDao {
    /**
     * Creates a mock VMInstanceDao with configurable stubbing for findById.
     *
     * @param idToVmMap a map from VM id to VMInstanceVO to be returned by findById
     * @return a mock VMInstanceDao with stubbing applied
     */
    public static VMInstanceDao createMockVMInstanceDao(Map<Long, VMInstanceVO> idToVmMap) {
        VMInstanceDao vmInstanceDao = Mockito.mock(VMInstanceDao.class);
        for (Map.Entry<Long, VMInstanceVO> entry : idToVmMap.entrySet()) {
            when(vmInstanceDao.findById(entry.getKey())).thenReturn(entry.getValue());
        }
        return vmInstanceDao;
    }
}

@Test

public void preparePublicNetworkTest() throws ConcurrentOperationException {

    Network network = mock(Network.class);

    NicProfile nicProfile = new NicProfile();

    VirtualMachineProfile virtualMachineProfile = mock(VirtualMachineProfile.class);

    DeployDestination deployDestination = mock(DeployDestination.class);

    ReservationContext reservationContext = mock(ReservationContext.class);

    VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);

    HostVO host = mock(HostVO.class);

    TungstenAnswer createTungstenVMAnswer = mock(TungstenAnswer.class);

    IPAddressVO ipAddressVO = mock(IPAddressVO.class);

    TungstenAnswer createTungstenNetworkPolicyAnswer = mock(TungstenAnswer.class);

    nicProfile.setIPv4Address("192.168.100.100");

    when(network.getTrafficType()).thenReturn(Networks.TrafficType.Public);

    when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);

    when(hostDao.findById(anyLong())).thenReturn(host);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenVirtualMachineCommand.class), anyLong())).thenReturn(createTungstenVMAnswer);

    when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(createTungstenNetworkPolicyAnswer);

    when(virtualMachineProfile.getType()).thenReturn(VirtualMachine.Type.ConsoleProxy);

    when(createTungstenVMAnswer.getResult()).thenReturn(true);

    when(createTungstenNetworkPolicyAnswer.getResult()).thenReturn(true);

    assertTrue(tungstenElement.prepare(network, nicProfile, virtualMachineProfile, deployDestination, reservationContext));

    assertEquals(Nic.ReservationStrategy.Create, nicProfile.getReservationStrategy());

    assertEquals(Networks.BroadcastDomainType.TUNGSTEN, nicProfile.getBroadcastType());

    assertEquals(Networks.BroadcastDomainType.TUNGSTEN.toUri("tf"), nicProfile.getBroadCastUri());

    assertEquals(TungstenUtils.DEFAULT_VHOST_INTERFACE, nicProfile.getName());

}

public class MockVMInstanceDao {
    public static VMInstanceDao createMockVMInstanceDao(VMInstanceVO vmInstanceVO) {
        VMInstanceDao vmInstanceDao = mock(VMInstanceDao.class);
        when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
        return vmInstanceDao;
    }
}

@Test

public void prepareManagementNetworkTest() throws ConcurrentOperationException {

    Network network = mock(Network.class);

    NicProfile nicProfile = new NicProfile();

    VirtualMachineProfile virtualMachineProfile = mock(VirtualMachineProfile.class);

    DeployDestination deployDestination = mock(DeployDestination.class);

    ReservationContext reservationContext = mock(ReservationContext.class);

    VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);

    HostVO host = mock(HostVO.class);

    TungstenAnswer createTungstenVMAnswer = mock(TungstenAnswer.class);

    nicProfile.setIPv4Address("192.168.100.100");

    when(network.getTrafficType()).thenReturn(Networks.TrafficType.Management);

    when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);

    when(hostDao.findById(anyLong())).thenReturn(host);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenVirtualMachineCommand.class), anyLong())).thenReturn(createTungstenVMAnswer);

    when(virtualMachineProfile.getType()).thenReturn(VirtualMachine.Type.SecondaryStorageVm);

    when(createTungstenVMAnswer.getResult()).thenReturn(true);

    assertTrue(tungstenElement.prepare(network, nicProfile, virtualMachineProfile, deployDestination, reservationContext));

    assertEquals(Nic.ReservationStrategy.Create, nicProfile.getReservationStrategy());

    assertEquals(Networks.BroadcastDomainType.TUNGSTEN, nicProfile.getBroadcastType());

    assertEquals(Networks.BroadcastDomainType.TUNGSTEN.toUri("tf"), nicProfile.getBroadCastUri());

    assertEquals(TungstenUtils.DEFAULT_VHOST_INTERFACE, nicProfile.getName());

}

public class MockVMInstanceDao {
    public static VMInstanceDao createMockVMInstanceDao(VMInstanceVO vmInstanceVO) {
        VMInstanceDao vmInstanceDao = mock(VMInstanceDao.class);
        when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
        return vmInstanceDao;
    }
}

@Test(expected = CloudRuntimeException.class)

public void prepareWithExceptionTest() throws ConcurrentOperationException {

    Network network = mock(Network.class);

    NicProfile nicProfile = new NicProfile();

    VirtualMachineProfile virtualMachineProfile = mock(VirtualMachineProfile.class);

    DeployDestination deployDestination = mock(DeployDestination.class);

    ReservationContext reservationContext = mock(ReservationContext.class);

    VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);

    HostVO host = mock(HostVO.class);

    TungstenAnswer createTungstenVMAnswer = mock(TungstenAnswer.class);

    nicProfile.setIPv4Address("192.168.100.100");

    when(network.getTrafficType()).thenReturn(Networks.TrafficType.Management);

    when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);

    when(hostDao.findById(anyLong())).thenReturn(host);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenVirtualMachineCommand.class), anyLong())).thenReturn(createTungstenVMAnswer);

    when(virtualMachineProfile.getType()).thenReturn(VirtualMachine.Type.SecondaryStorageVm);

    tungstenElement.prepare(network, nicProfile, virtualMachineProfile, deployDestination, reservationContext);

}

public class MockVMInstanceDao {
    public static VMInstanceDao createMockVMInstanceDao(VMInstanceVO vmInstanceVO) {
        VMInstanceDao vmInstanceDao = mock(VMInstanceDao.class);
        when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
        return vmInstanceDao;
    }
}

@Test

public void releasePublicNetworkTest() throws ConcurrentOperationException, ResourceUnavailableException {

    Network network = mock(Network.class);

    NicProfile nicProfile = mock(NicProfile.class);

    VirtualMachineProfile virtualMachineProfile = mock(VirtualMachineProfile.class);

    ReservationContext reservationContext = mock(ReservationContext.class);

    VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);

    HostVO host = mock(HostVO.class);

    IPAddressVO ipAddressVO = mock(IPAddressVO.class);

    TungstenAnswer deleteTungstenVRouterPortAnswer = mock(TungstenAnswer.class);

    TungstenAnswer deleteVmiAnswer = mock(TungstenAnswer.class);

    TungstenAnswer deleteVmAnswer = mock(TungstenAnswer.class);

    TungstenAnswer deleteTungstenNetworkPolicyAnswer = mock(TungstenAnswer.class);

    when(nicProfile.getIPv4Address()).thenReturn("192.168.100.100");

    when(network.getTrafficType()).thenReturn(Networks.TrafficType.Public);

    when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);

    when(hostDao.findById(anyLong())).thenReturn(host);

    when(virtualMachineProfile.getType()).thenReturn(VirtualMachine.Type.SecondaryStorageVm);

    when(ipAddressDao.findByIpAndDcId(anyLong(), anyString())).thenReturn(ipAddressVO);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVRouterPortCommand.class), anyLong())).thenReturn(deleteTungstenVRouterPortAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmInterfaceCommand.class), anyLong())).thenReturn(deleteVmiAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmCommand.class), anyLong())).thenReturn(deleteVmAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenNetworkPolicyCommand.class), anyLong())).thenReturn(deleteTungstenNetworkPolicyAnswer);

    when(deleteTungstenVRouterPortAnswer.getResult()).thenReturn(true);

    when(deleteVmiAnswer.getResult()).thenReturn(true);

    when(deleteVmAnswer.getResult()).thenReturn(true);

    when(deleteTungstenNetworkPolicyAnswer.getResult()).thenReturn(true);

    assertTrue(tungstenElement.release(network, nicProfile, virtualMachineProfile, reservationContext));

}

public class MockVMInstanceDao {
    public static VMInstanceDao createMockVMInstanceDao(VMInstanceVO vmInstanceVO) {
        VMInstanceDao vmInstanceDao = mock(VMInstanceDao.class);
        when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
        return vmInstanceDao;
    }
}

@Test

public void releaseManagementNetworkTest() throws ConcurrentOperationException, ResourceUnavailableException {

    Network network = mock(Network.class);

    NicProfile nicProfile = mock(NicProfile.class);

    VirtualMachineProfile virtualMachineProfile = mock(VirtualMachineProfile.class);

    ReservationContext reservationContext = mock(ReservationContext.class);

    VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);

    HostVO host = mock(HostVO.class);

    TungstenAnswer deleteTungstenVRouterPortAnswer = mock(TungstenAnswer.class);

    TungstenAnswer deleteVmiAnswer = mock(TungstenAnswer.class);

    TungstenAnswer deleteVmAnswer = mock(TungstenAnswer.class);

    when(nicProfile.getIPv4Address()).thenReturn("192.168.100.100");

    when(network.getTrafficType()).thenReturn(Networks.TrafficType.Management);

    when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);

    when(hostDao.findById(anyLong())).thenReturn(host);

    when(virtualMachineProfile.getType()).thenReturn(VirtualMachine.Type.SecondaryStorageVm);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVRouterPortCommand.class), anyLong())).thenReturn(deleteTungstenVRouterPortAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmInterfaceCommand.class), anyLong())).thenReturn(deleteVmiAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmCommand.class), anyLong())).thenReturn(deleteVmAnswer);

    when(deleteTungstenVRouterPortAnswer.getResult()).thenReturn(true);

    when(deleteVmiAnswer.getResult()).thenReturn(true);

    when(deleteVmAnswer.getResult()).thenReturn(true);

    assertTrue(tungstenElement.release(network, nicProfile, virtualMachineProfile, reservationContext));

}

public class MockVMInstanceDao {
    public static VMInstanceDao createMockVMInstanceDao(VMInstanceVO vmInstanceVO) {
        VMInstanceDao vmInstanceDao = mock(VMInstanceDao.class);
        when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
        return vmInstanceDao;
    }
}

@Test(expected = CloudRuntimeException.class)

public void releaseWithExceptionTest() throws ConcurrentOperationException, ResourceUnavailableException {

    Network network = mock(Network.class);

    NicProfile nicProfile = mock(NicProfile.class);

    VirtualMachineProfile virtualMachineProfile = mock(VirtualMachineProfile.class);

    ReservationContext reservationContext = mock(ReservationContext.class);

    VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);

    HostVO host = mock(HostVO.class);

    TungstenAnswer deleteTungstenVRouterPortAnswer = mock(TungstenAnswer.class);

    TungstenAnswer deleteVmiAnswer = mock(TungstenAnswer.class);

    when(nicProfile.getIPv4Address()).thenReturn("192.168.100.100");

    when(network.getTrafficType()).thenReturn(Networks.TrafficType.Management);

    when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);

    when(hostDao.findById(anyLong())).thenReturn(host);

    when(virtualMachineProfile.getType()).thenReturn(VirtualMachine.Type.SecondaryStorageVm);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVRouterPortCommand.class), anyLong())).thenReturn(deleteTungstenVRouterPortAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmInterfaceCommand.class), anyLong())).thenReturn(deleteVmiAnswer);

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVmCommand.class), anyLong())).thenThrow(IllegalArgumentException.class);

    when(deleteTungstenVRouterPortAnswer.getResult()).thenReturn(true);

    when(deleteVmiAnswer.getResult()).thenReturn(true);

    tungstenElement.release(network, nicProfile, virtualMachineProfile, reservationContext);

}

public class MockVMInstanceDao {
    public static VMInstanceDao createMockVMInstanceDao(VMInstanceVO vmInstanceVO) {
        VMInstanceDao vmInstanceDao = mock(VMInstanceDao.class);
        when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
        return vmInstanceDao;
    }
}

@Test

public void prepareMigrationTest() {

    NicProfile nic = mock(NicProfile.class);

    Network network = mock(Network.class);

    VirtualMachineProfile vm = mock(VirtualMachineProfile.class);

    DeployDestination dest = mock(DeployDestination.class);

    ReservationContext context = mock(ReservationContext.class);

    VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);

    HostVO hostVO = mock(HostVO.class);

    TungstenAnswer tungstenAnswer = mock(TungstenAnswer.class);

    when(vm.getType()).thenReturn(VirtualMachine.Type.ConsoleProxy);

    when(network.getTrafficType()).thenReturn(Networks.TrafficType.Public);

    when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);

    when(hostDao.findById(anyLong())).thenReturn(hostVO);

    when(tungstenFabricUtils.sendTungstenCommand(any(CreateTungstenVirtualMachineCommand.class), anyLong())).thenReturn(tungstenAnswer);

    when(tungstenAnswer.getResult()).thenReturn(true);

    assertTrue(tungstenElement.prepareMigration(nic, network, vm, dest, context));

}

public class MockVMInstanceDao {
    public static VMInstanceDao createMockVMInstanceDao(VMInstanceVO vmInstanceVO) {
        VMInstanceDao vmInstanceDao = mock(VMInstanceDao.class);
        when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
        return vmInstanceDao;
    }
}

@Test

public void testReserve() throws InsufficientVirtualNetworkCapacityException, InsufficientAddressCapacityException {

    final NicProfile nic = mock(NicProfile.class);

    final Network network = mock(Network.class);

    final VirtualMachineProfile vm = mock(VirtualMachineProfile.class);

    final DeployDestination dest = mock(DeployDestination.class);

    final ReservationContext context = mock(ReservationContext.class);

    final VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);

    final HostVO host = mock(HostVO.class);

    when(nic.getReservationStrategy()).thenReturn(Nic.ReservationStrategy.Start);

    when(vm.getType()).thenReturn(VirtualMachine.Type.User);

    when(network.getTrafficType()).thenReturn(Networks.TrafficType.Guest);

    when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);

    when(hostDao.findById(anyLong())).thenReturn(host);

    guru.reserve(nic, network, vm, dest, context);

    verify(tungstenFabricUtils, times(1)).sendTungstenCommand(any(CreateTungstenVirtualMachineCommand.class), anyLong());

}

public class MockVMInstanceDao {
    public static VMInstanceDao createMockVMInstanceDao(VMInstanceVO vmInstanceVO) {
        VMInstanceDao vmInstanceDao = mock(VMInstanceDao.class);
        when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);
        return vmInstanceDao;
    }
}

@Test

public void testRelease() {

    final NicProfile nic = mock(NicProfile.class);

    final VirtualMachineProfile vm = mock(VirtualMachineProfile.class);

    final IPAddressVO ipAddressVO = mock(IPAddressVO.class);

    final VMInstanceVO vmInstanceVO = mock(VMInstanceVO.class);

    final HostVO host = mock(HostVO.class);

    when(vm.getType()).thenReturn(VirtualMachine.Type.User);

    when(hostDao.findById(anyLong())).thenReturn(host);

    when(ipAddressDao.findByAssociatedVmId(anyLong())).thenReturn(ipAddressVO);

    when(networkModel.getSystemNetworkByZoneAndTrafficType(anyLong(), any())).thenReturn(new NetworkVO());

    when(tungstenFabricUtils.sendTungstenCommand(any(ReleaseTungstenFloatingIpCommand.class), anyLong())).thenReturn(new TungstenAnswer(new TungstenCommand(), true, ""));

    when(tungstenFabricUtils.sendTungstenCommand(any(DeleteTungstenVRouterPortCommand.class), anyLong())).thenReturn(new TungstenAnswer(new TungstenCommand(), true, ""));

    when(vmInstanceDao.findById(anyLong())).thenReturn(vmInstanceVO);

    guru.release(nic, vm, "test");

    verify(tungstenFabricUtils, times(1)).sendTungstenCommand(any(DeleteTungstenVRouterPortCommand.class), anyLong());

}